Systems and methods for continuous data protection with near zero recovery point

ABSTRACT

Example embodiments relate generally to systems and methods for continuous data protection (CDP) and more specifically to an input and output (I/O) filtering framework and log management system to seek a near-zero recovery point objective (RPO).

CROSS-REFERENCE TO RELATED APPLICATION

This application is a continuation of U.S. patent application Ser. No.16/398,534, filed Apr. 30, 2019, which application and publication isincorporated herein by reference in its entirety.

FIELD

The present disclosure relates generally to systems and methods forcontinuous data protection and more specifically to an input and output(I/O) filtering framework and log management system to seek a near-zerorecovery point objective (RPO).

BACKGROUND

Virtual machines (VM's) that include virtual disks are sometimes backedup by taking snapshots. Due to certain limitations of existing snapshottechnology, snapshots cannot be taken frequently without impacting VMusers. Typical snapshot-based backup and recovery technology providesRPOs in the tens of minutes.

In a snapshot-based approach, a base snapshot is taken when a protectionpolicy under a service level agreement (SLA) for example is enabled on aVM and its virtual disks. After the base snapshot is saved on a backupsite, incremental snapshots are taken periodically. A delta between twosnapshots represents data blocks that have changed, and these blocks maybe sent to and stored on a backup site for recovery when needed. Sincetaking snapshots is an expensive operation and may impact users,snapshots are typically taken some minutes apart, often from the tens ofminutes to several hours, and this in turn can result in a very poorRPO.

SUMMARY

In some examples, virtual disk I/Os are intercepted in an I/O paththereby allowing the I/O to be replicated to a backup site at near realtime with minimal user impacts, substantially eliminating the need totake snapshots periodically. RPO may be reduced down to seconds. In someexamples, a log management system oversees and controls a log streamreceived at the backup site.

In an example embodiment, a system is provided for continuous dataprotection for a virtual machine (VM) having a virtual disk. The systemmay comprise at least one processor for executing machine-readableinstructions; and a memory storing instructions configured to cause theat least one processor to perform operations comprising, at least:obtaining a base snapshot of the virtual disk; intercepting, at aninterception point in an I/O path, a virtual disk I/O stream between theVM and a virtualization server; replicating the I/O stream at a backupsite; storing the replicated I/O stream at the backup site in I/O logs;forming a recoverable snapshot-log chain by applying the replicated I/Ostream stored in the I/O logs on top of the base snapshot; receiving arequest for recoverable data from a replication target; and sending datato the replication target based at least on a portion of the recoverablesnapshot-log chain.

In another example embodiment, a system is provided for optimizing arecovery point objective (RPO) in a virtual machine (VM) having avirtual disk. The system may comprise at least one processor forexecuting machine-readable instructions, and a memory storinginstructions configured to cause the at least one processor to performoperations comprising, at least: tapping off I/O data at avirtualization server by a filter framework; collecting the I/O data ata filter stack, and providing a filter touchpoint selection at thefilter framework to parse the tapped off I/O data and configure itscollection; sending a parsed section of the collected I/O data to a logreceiver for storage as a log-chain in an I/O log; receiving a requestfor recoverable data from a replication target; and causing orfacilitating a transmission of requested data to the replication targetbased at least on a portion of the stored log-chain.

In another example embodiment, a system is provided for continuous dataprotection for a virtual machine (VM) having a virtual disk. The systemmay comprise at least one processor for executing machine-readableinstructions; and a memory storing instructions configured to cause theat least one processor to perform operations comprising, at least:obtaining a base snapshot of the virtual disk; intercepting, at aninterception point in an I/O path, a virtual disk I/O stream between theVM and a virtualization server; replicating the I/O stream at a logreceiver, and storing the replicated I/O stream at the log receiver inI/O logs; forming a recoverable snapshot-log chain by applying thereplicated I/O stream stored in the I/O logs on top of the basesnapshot; receiving, via a graphical user interface, a user request forrecoverable data at a replication target, the request based on arecovery protocol including a recovery point objective (RPO) of lessthan 60 seconds; and meeting or exceeding the RPO by sending data lessthan 60 seconds old to the replication target based at least on aportion of the recoverable snapshot-log chain.

In another example embodiment, a system is provided for continuous dataprotection for a virtual machine (VM) having a virtual disk. The systemmay comprise at least one processor for executing machine-readableinstructions; and a memory storing instructions configured to cause theat least one processor to perform operations comprising, at least:capturing a base snapshot of the virtual disk; receiving, at a backupsite, I/O data from an intercepted I/O stream between the VM and avirtualization server; buffering the received I/O data into memory andflushing the I/O data to a log file; including a log file with the basesnapshot in an I/O log to form a recoverable snapshot-log chain;determining a request for recoverable data from a replication target;and pushing the requested data to the replication target based at leaston a portion of the recoverable snapshot-log chain.

In another example embodiment, a system is provided for optimizing arecovery point objective (RPO) for a virtual machine (VM) having avirtual disk. The system may comprise at least one processor forexecuting machine-readable instructions; and a memory storinginstructions configured to cause the at least one processor to performoperations comprising, at least: storing a base snapshot of the virtualdisk; receiving, at a log receiver, I/O data from an intercepted I/Ostream between the VM and a virtualization server; storing, at the logreceiver, the I/O data as a plurality of log chains in one or more logfiles; associating a log chain in the plurality of log chains with thebase snapshot to form a recoverable snapshot-log chain; receiving arequest for recoverable data from a replication target; and transmittingthe requested data to the replication target including at least on aportion of the recoverable snapshot-log chain.

In another example embodiment, a system is provided for optimizing arecovery point objective (RPO) for a virtual machine (VM) having avirtual disk. The system may comprise at least one processor forexecuting machine-readable instructions; and a memory storinginstructions configured to cause the at least one processor to performoperations comprising, at least: storing a base snapshot of the virtualdisk; receiving, at a log receiver, I/O data from an intercepted I/Ostream source between the VM and a virtualization server; storing theI/O data at the log receiver in one or more log files, the I/O dataincluding a plurality of log chains; associating a log chain in theplurality of log chains with the base snapshot to form a recoverablesnapshot-log chain; receiving a request for recoverable data from areplication target; and transmitting the requested data including atleast on a portion of the recoverable snapshot-log chain to a diskseeking replication at the replication target.

In another example embodiment, a system is provided for continuous dataprotection for a virtual machine (VM) having a virtual disk, the systemcomprising: at least one processor for executing machine-readableinstructions; and a memory storing instructions configured to cause theat least one processor to perform operations comprising, at least:determining an existence or availability of a base snapshot of thevirtual disk; intercepting, at an interception point in an I/O path, avirtual disk I/O stream between the VM and a virtualization server;replicating the I/O stream at a backup site; storing the replicated I/Ostream at the backup site in I/O logs; based on the existence oravailability of the base snapshot, forming a recoverable snapshot-logchain by applying the replicated I/O stream stored in the I/O logs ontop of the base snapshot; receiving a request for recoverable data froma replication target; and sending data to the replication target basedat least on a portion of the recoverable snapshot-log chain.

In another example embodiment, a system is provided for continuous dataprotection for a virtual machine (VM) having a virtual disk, the systemcomprising: at least one processor for executing machine-readableinstructions; and a memory storing instructions configured to cause theat least one processor to perform operations comprising, at least:determining an existence or availability of a base snapshot of thevirtual disk; intercepting, at an interception point in an I/O path, avirtual disk I/O stream between the VM and a virtualization server;replicating the I/O stream at a backup site; storing the replicated I/Ostream at the backup site in I/O logs; based on the existence oravailability of the base snapshot, forming a recoverable snapshot-logchain by applying the replicated I/O stream stored in the I/O logs ontop of the base snapshot; receiving a request for recoverable data froma replication target; and sending data to the replication target basedat least on a portion of the recoverable snapshot-log chain.

In another example embodiment, a system is provided for continuous dataprotection, the system comprising: at least one processor for executingmachine-readable instructions; and a memory storing instructionsconfigured to cause the at least one processor to perform operationscomprising, at least: obtaining or identifying recoverable ranges of aVM; and recovering the VM from a most recent continuous point-in-timeversion of the virtual disk or a specific continuous point-in-timeversion of the virtual disk by implementing a set of algorithms, the setof algorithms to determine if a log chain in a series of log chainsstored at a recovery site is valid for recovery of the VM, wherein afirst algorithm of the set of algorithms includes determining a shortestlog chain having a valid base snapshot, and a second algorithm in theset of algorithms includes determining a longest log chain having avalid base snapshot.

In another example embodiment, a system is provided for continuous dataprotection for a virtual machine (VM) having a virtual disk, the systemcomprising: at least one processor for executing machine-readableinstructions; and a memory storing instructions configured to cause theat least one processor to perform operations comprising, at least:intercepting, at an interception point in an I/O path, a virtual diskI/O stream between the VM and a virtualization server; storing the I/Ostream at a backup site; forming a recoverable snapshot-log chain byassociating the stored I/O stream with a base snapshot; receiving arequest for recoverable data from a replication target; and sending datato the replication target based at least on a portion of the recoverablesnapshot-log chain.

DESCRIPTION OF THE DRAWINGS

Some embodiments are illustrated by way of example and not limitation inthe figures of the accompanying drawings:

FIG. 1 depicts one embodiment of a networked computing environment 100with which the disclosed technology may be practiced, according to anexample embodiment.

FIG. 2 depicts one embodiment of server 160 in FIG. 1, according to anexample embodiment.

FIG. 3 depicts one embodiment of storage appliance 170 in FIG. 1,according to an example embodiment.

FIG. 4 depicts a networked environment, according to an exampleembodiment.

FIGS. 5-6 show timelines of example use cases, according to an exampleembodiment.

FIGS. 7-10 depict networked environments, according to exampleembodiments.

FIG. 11 shows aspects of an example log receiver, according to anexample embodiment.

FIGS. 12-25 shows aspects of an example log chains (also termedsnapshot-log chains herein, depending on the context), according toexample embodiments.

FIGS. 26-31 and 35-38 are flow charts depicting example operations inmethods, according to example embodiments.

FIG. 32 depicts a block diagram illustrating an example of a softwarearchitecture that may be installed on a machine, according to someexample embodiments.

FIG. 33 depicts a block diagram illustrating an architecture ofsoftware, according to an example embodiment.

FIG. 34 illustrates a diagrammatic representation of a machine in theform of a computer system within which a set of instructions may beexecuted for causing a machine to perform any one or more of themethodologies discussed herein, according to an example embodiment.

DESCRIPTION

The description that follows includes systems, methods, techniques,instruction sequences, and computing machine program products thatembody illustrative embodiments of the present disclosure. In thefollowing description, for purposes of explanation, numerous specificdetails are set forth in order to provide a thorough understanding ofexample embodiments. It will be evident, however, to one skilled in theart that the present invention may be practiced without these specificdetails.

A portion of the disclosure of this patent document contains materialthat is subject to copyright protection. The copyright owner has noobjection to the facsimile reproduction by anyone of the patent documentor the patent disclosure, as it appears in the Patent and TrademarkOffice patent files or records, but otherwise reserves all copyrightrights whatsoever. The following notice applies to the software and dataas described below and in the drawings that form a part of thisdocument: Copyright Rubrik, Inc., 2018-2019, All Rights Reserved.

FIG. 1 depicts one embodiment of a networked computing environment 100in which the disclosed technology may be practiced. As depicted, thenetworked computing environment 100 includes a data center 150, astorage appliance 140, and a computing device 154 in communication witheach other via one or more networks 180. The networked computingenvironment 100 may include a plurality of computing devicesinterconnected through one or more networks 180. The one or morenetworks 180 may allow computing devices and/or storage devices toconnect to and communicate with other computing devices and/or otherstorage devices. In some cases, the networked computing environment mayinclude other computing devices and/or other storage devices not shown.The other computing devices may include, for example, a mobile computingdevice, a non-mobile computing device, a server, a work-station, alaptop computer, a tablet computer, a desktop computer, or aninformation processing system. The other storage devices may include,for example, a storage area network storage device, a networked-attachedstorage device, a hard disk drive, a solid-state drive, or a datastorage system.

The data center 150 may include one or more servers, such as server 160,in communication with one or more storage devices, such as storagedevice 156. The one or more servers may also be in communication withone or more storage appliances, such as storage appliance 170. Theserver 160, storage device 156, and storage appliance 170 may be incommunication with each other via a networking fabric connecting serversand data storage units within the data center to each other. The storageappliance 170 may include a data management system for backing upvirtual machines and/or files within a virtualized infrastructure. Theserver 160 may be used to create and manage one or more virtual machinesassociated with a virtualized infrastructure.

The one or more virtual machines may run various applications, such as adatabase application or a web server. The storage device 156 may includeone or more hardware storage devices for storing data, such as a harddisk drive (HDD), a magnetic tape drive, a solid-state drive (SSD), astorage area network (SAN) storage device, or a Networked-AttachedStorage (NAS) device. In some cases, a data center, such as data center150, may include thousands of servers and/or data storage devices incommunication with each other. The data storage devices may comprise atiered data storage infrastructure (or a portion of a tiered datastorage infrastructure). The tiered data storage infrastructure mayallow for the movement of data across different tiers of a data storageinfrastructure between higher-cost, higher-performance storage devices(e.g., solid-state drives and hard disk drives) and relativelylower-cost, lower-performance storage devices (e.g., magnetic tapedrives).

The one or more networks 180 may include a secure network such as anenterprise private network, an unsecured network such as a wireless opennetwork, a local area network (LAN), a wide area network (WAN), and theInternet. The one or more networks 180 may include a cellular network, amobile network, a wireless network, or a wired network. Each network ofthe one or more networks 180 may include hubs, bridges, routers,switches, and wired transmission media such as a direct-wiredconnection. The one or more networks 180 may include an extranet orother private network for securely sharing information or providingcontrolled access to applications or files.

A server, such as server 160, may allow a client to download informationor files (e.g., executable, text, application, audio, image, or videofiles) from the server or to perform a search query related toparticular information stored on the server. In some cases, a server mayact as an application server or a file server. In general, a server mayrefer to a hardware device that acts as the host in a client-serverrelationship or a software process that shares a resource with orperforms work for one or more clients.

One embodiment of server 160 includes a network interface 165, aprocessor 166, a memory 167, a disk 168, and a virtualization manager169 all in communication with each other. Network interface 165 allowsthe server 160 to connect to one or more networks 180. Network interface165 may include a wireless network interface and/or a wired networkinterface. Processor 166 allows server 160 to execute computer readableinstructions stored in memory 167 in order to perform processesdescribed herein. Processor 166 may include one or more processingunits, such as one or more CPUs and/or one or more GPUs. Memory 167 maycomprise one or more types of memory (e.g., RAM, SRAM, DRAM, ROM,EEPROM, Flash, etc.). Disk 168 may include a hard disk drive and/or asolid-state drive. Memory 167 and disk 168 may comprise hardware storagedevices.

The virtualization manager 169 may manage a virtualized infrastructureand perform management operations associated with the virtualizedinfrastructure. The virtualization manager 169 may manage theprovisioning of virtual machines running within the virtualizedinfrastructure and provide an interface to computing devices interactingwith the virtualized infrastructure. In one example, the virtualizationmanager 169 may set a virtual machine into a frozen state in response toa snapshot request made via an application programming interface (API)by a storage appliance, such as storage appliance 170. Setting thevirtual machine into a frozen state may allow a point in time snapshotof the virtual machine to be stored or transferred. In one example,updates made to a virtual machine that has been set into a frozen statemay be written to a separate file (e.g., an update file) while thevirtual disk file may be set into a read-only state to preventmodifications to the virtual disk file while the virtual machine is inthe frozen state.

The virtualization manager 169 may then transfer data associated withthe virtual machine (e.g., an image of the virtual machine or a portionof the image of the virtual disk file associated with the state of thevirtual disk at the point in time is frozen) to a storage appliance inresponse to a request made by the storage appliance 170. After the dataassociated with the point in time snapshot of the virtual machine hasbeen transferred to the storage appliance, the virtual machine may bereleased from the frozen state (i.e., unfrozen) and the updates made tothe virtual machine and stored in the separate file may be merged intothe virtual disk file. The virtualization manager 169 may performvarious virtual machine related tasks, such as cloning virtual machines,creating new virtual machines, monitoring the state of virtual machines,moving virtual machines between physical hosts for load balancingpurposes, and facilitating backups of virtual machines.

One embodiment of storage appliance 170 includes a network interface175, processor 176, memory 177, and disk 178 all in communication witheach other. Network interface 175 allows storage appliance 170 toconnect to one or more networks 180. Network interface 175 may include awireless network interface and/or a wired network interface. Processor176 allows storage appliance 170 to execute computer readableinstructions stored in memory 177 in order to perform processesdescribed herein. Processor 176 may include one or more processingunits, such as one or more CPUs and/or one or more GPUs. Memory 177 maycomprise one or more types of memory (e.g., RAM, SRAM, DRAM, ROM,EEPROM, NOR Flash, NAND Flash, etc.). Disk 178 may include a hard diskdrive and/or a solid-state drive. Memory 177 and disk 178 may comprisehardware storage devices.

In one embodiment, the storage appliance 170 may include four machines.Each of the four machines may include a multi-core CPU, 64 GB of RAM, a400 GB SSD, three 4 TB HDDs, and a network interface controller. In thiscase, the four machines may be in communication with the one or morenetworks 180 via the four network interface controllers. The fourmachines may comprise four nodes of a server cluster. The server clustermay comprise a set of physical machines that are connected together viaa network. The server cluster may be used for storing data associatedwith a plurality of virtual machines, such as backup data associatedwith different point in time versions of virtual machines.

The networked computing environment 100 may provide a cloud computingenvironment for one or more computing devices. Cloud computing may referto Internet-based computing, wherein shared resources, software, and/orinformation may be provided to one or more computing devices on-demandvia the Internet. The networked computing environment 100 may comprise acloud computing environment providing Software-as-a-Service (SaaS) orInfrastructure-as-a-Service (IaaS) services. SaaS may refer to asoftware distribution model in which applications are hosted by aservice provider and made available to end users over the Internet. Inone embodiment, the networked computing environment 100 may include avirtualized infrastructure that provides software, data processing,and/or data storage services to end users accessing the services via thenetworked computing environment. In one example, networked computingenvironment 100 may provide cloud-based work productivity orbusiness-related applications to a computing device, such as computingdevice 154. The storage appliance 140 may comprise a cloud-based datamanagement system for backing up virtual machines and/or files within avirtualized infrastructure, such as virtual machines running on server160 or files stored on server 160.

In some cases, networked computing environment 100 may provide remoteaccess to secure applications and files stored within data center 150from a remote computing device, such as computing device 154. The datacenter 150 may use an access control application to manage remote accessto protected resources, such as protected applications, databases, orfiles located within the data center. To facilitate remote access tosecure applications and files, a secure network connection may beestablished using a virtual private network (VPN). A VPN connection mayallow a remote computing device, such as computing device 154, tosecurely access data from a private network (e.g., from a company fileserver or mail server) using an unsecure public network or the Internet.The VPN connection may require client-side software (e.g., running onthe remote computing device) to establish and maintain the VPNconnection. The VPN client software may provide data encryption andencapsulation prior to the transmission of secure private networktraffic through the Internet.

In some embodiments, the storage appliance 170 may manage the extractionand storage of virtual machine snapshots associated with different pointin time versions of one or more virtual machines running within the datacenter 150. A snapshot of a virtual machine may correspond with a stateof the virtual machine at a particular point in time. In response to arestore command from the server 160, the storage appliance 170 mayrestore a point in time version of a virtual machine or restore point intime versions of one or more files located on the virtual machine andtransmit the restored data to the server 160. In response to a mountcommand from the server 160, the storage appliance 170 may allow a pointin time version of a virtual machine to be mounted and allow the server160 to read and/or modify data associated with the point in time versionof the virtual machine. To improve storage density, the storageappliance 170 may deduplicate and compress data associated withdifferent versions of a virtual machine and/or deduplicate and compressdata associated with different virtual machines. To improve systemperformance, the storage appliance 170 may first store virtual machinesnapshots received from a virtualized environment in a cache, such as aflash-based cache. The cache may also store popular data or frequentlyaccessed data (e.g., based on a history of virtual machine restorations,incremental files associated with commonly restored virtual machineversions) and current day incremental files or incremental filescorresponding with snapshots captured within the past 24 hours.

An incremental file may comprise a forward incremental file or a reverseincremental file. A forward incremental file may include a set of datarepresenting changes that have occurred since an earlier point in timesnapshot of a virtual machine. To generate a snapshot of the virtualmachine corresponding with a forward incremental file, the forwardincremental file may be combined with an earlier point in time snapshotof the virtual machine (e.g., the forward incremental file may becombined with the last full image of the virtual machine that wascaptured before the forward incremental was captured and any otherforward incremental files that were captured subsequent to the last fullimage and prior to the forward incremental file). A reverse incrementalfile may include a set of data representing changes from a later pointin time snapshot of a virtual machine. To generate a snapshot of thevirtual machine corresponding with a reverse incremental file, thereverse incremental file may be combined with a later point in timesnapshot of the virtual machine (e.g., the reverse incremental file maybe combined with the most recent snapshot of the virtual machine and anyother reverse incremental files that were captured prior to the mostrecent snapshot and subsequent to the reverse incremental file).

The storage appliance 170 may provide a user interface (e.g., aweb-based interface or a graphical user interface) that displays virtualmachine backup information such as identifications of the virtualmachines protected and the historical versions or time machine views foreach of the virtual machines protected. A time machine view of a virtualmachine may include snapshots of the virtual machine over a plurality ofpoints in time. Each snapshot may comprise the state of the virtualmachine at a particular point in time. Each snapshot may correspond witha different version of the virtual machine (e.g., Version 1 of a virtualmachine may correspond with the state of the virtual machine at a firstpoint in time and Version 2 of the virtual machine may correspond withthe state of the virtual machine at a second point in time subsequent tothe first point in time).

The user interface may enable an end user of the storage appliance 170(e.g., a system administrator or a virtualization administrator) toselect a particular version of a virtual machine to be restored ormounted. When a particular version of a virtual machine has beenmounted, the particular version may be accessed by a client (e.g., avirtual machine, a physical machine, or a computing device) as if theparticular version was local to the client. A mounted version of avirtual machine may correspond with a mount point directory (e.g.,/snapshots/VM5Nersion23). In one example, the storage appliance 170 mayrun an NFS server and make the particular version (or a copy of theparticular version) of the virtual machine accessible for reading and/orwriting. The end user of the storage appliance 170 may then select theparticular version to be mounted and run an application (e.g., a dataanalytics application) using the mounted version of the virtual machine.In another example, the particular version may be mounted as an iSCSItarget.

FIG. 2 depicts one embodiment of server 160 in FIG. 1. The server 160may comprise one server out of a plurality of servers that are networkedtogether within a data center. In one example, the plurality of serversmay be positioned within one or more server racks within the datacenter. As depicted, the server 160 includes hardware-level componentsand software-level components. The hardware-level components include oneor more processors 182, one or more memory 184, and one or more disks185. The software-level components include a hypervisor 186, avirtualized infrastructure manager 199, and one or more virtualmachines, such as virtual machine 198. The hypervisor 186 may comprise anative hypervisor or a hosted hypervisor. The hypervisor 186 may providea virtual operating platform for running one or more virtual machines,such as virtual machine 198. Virtual machine 198 includes a plurality ofvirtual hardware devices including a virtual processor 192, a virtualmemory 194, and a virtual disk 195. The virtual disk 195 may comprise afile stored within the one or more disks 185. In one example, a virtualmachine may include a plurality of virtual disks, with each virtual diskof the plurality of virtual disks associated with a different filestored on the one or more disks 185. Virtual machine 198 may include aguest operating system 196 that runs one or more applications, such asapplication 197.

The virtualized infrastructure manager 199, which may correspond withthe virtualization manager 169 in FIG. 1, may run on a virtual machineor natively on the server 160. The virtualized infrastructure manager199 may provide a centralized platform for managing a virtualizedinfrastructure that includes a plurality of virtual machines. Thevirtualized infrastructure manager 199 may manage the provisioning ofvirtual machines running within the virtualized infrastructure andprovide an interface to computing devices interacting with thevirtualized infrastructure. The virtualized infrastructure manager 199may perform various virtualized infrastructure related tasks, such ascloning virtual machines, creating new virtual machines, monitoring thestate of virtual machines, and facilitating backups of virtual machines.

In one embodiment, the server 160 may use the virtualized infrastructuremanager 199 to facilitate backups for a plurality of virtual machines(e.g., eight different virtual machines) running on the server 160. Eachvirtual machine running on the server 160 may run its own guestoperating system and its own set of applications. Each virtual machinerunning on the server 160 may store its own set of files using one ormore virtual disks associated with the virtual machine (e.g., eachvirtual machine may include two virtual disks that are used for storingdata associated with the virtual machine).

In one embodiment, a data management application running on a storageappliance, such as storage appliance 140 in FIG. 1 or storage appliance170 in FIG. 1, may request a snapshot of a virtual machine running onserver 160. The snapshot of the virtual machine may be stored as one ormore files, with each file associated with a virtual disk of the virtualmachine. A snapshot of a virtual machine may correspond with a state ofthe virtual machine at a particular point in time. The particular pointin time may be associated with a time stamp. In one example, a firstsnapshot of a virtual machine may correspond with a first state of thevirtual machine (including the state of applications and files stored onthe virtual machine) at a first point in time and a second snapshot ofthe virtual machine may correspond with a second state of the virtualmachine at a second point in time subsequent to the first point in time.

In response to a request for a snapshot of a virtual machine at aparticular point in time, the virtualized infrastructure manager 199 mayset the virtual machine into a frozen state or store a copy of thevirtual machine at the particular point in time. The virtualizedinfrastructure manager 199 may then transfer data associated with thevirtual machine (e.g., an image of the virtual machine or a portion ofthe image of the virtual machine) to the storage appliance. The dataassociated with the virtual machine may include a set of files includinga virtual disk file storing contents of a virtual disk of the virtualmachine at the particular point in time and a virtual machineconfiguration file storing configuration settings for the virtualmachine at the particular point in time. The contents of the virtualdisk file may include the operating system used by the virtual machine,local applications stored on the virtual disk, and user files (e.g.,images and word processing documents). In some cases, the virtualizedinfrastructure manager 199 may transfer a full image of the virtualmachine to the storage appliance or a plurality of data blockscorresponding with the full image (e.g., to enable a full image-levelbackup of the virtual machine to be stored on the storage appliance). Inother cases, the virtualized infrastructure manager 199 may transfer aportion of an image of the virtual machine associated with data that haschanged since an earlier point in time prior to the particular point intime or since a last snapshot of the virtual machine was taken. In oneexample, the virtualized infrastructure manager 199 may transfer onlydata associated with virtual blocks stored on a virtual disk of thevirtual machine that have changed since the last snapshot of the virtualmachine was taken. In one embodiment, the data management applicationmay specify a first point in time and a second point in time and thevirtualized infrastructure manager 199 may output one or more virtualdata blocks associated with the virtual machine that have been modifiedbetween the first point in time and the second point in time.

In some embodiments, the server 160 may or the hypervisor 186 maycommunicate with a storage appliance, such as storage appliance 140 inFIG. 1 or storage appliance 170 in FIG. 1, using a distributed filesystem protocol such as Network File System (NFS) Version 3, or ServerMessage Block (SMB) protocol. The distributed file system protocol mayallow the server 160 or the hypervisor 186 to access, read, write, ormodify files stored on the storage appliance as if the files werelocally stored on the server. The distributed file system protocol mayallow the server 160 or the hypervisor 186 to mount a directory or aportion of a file system located within the storage appliance.

FIG. 3 depicts one embodiment of storage appliance 170 in FIG. 1. Thestorage appliance may include a plurality of physical machines that maybe grouped together and presented as a single computing system. Eachphysical machine of the plurality of physical machines may comprise anode in a cluster (e.g., a failover cluster). In one example, thestorage appliance may be positioned within a server rack within a datacenter. As depicted, the storage appliance 170 includes hardware-levelcomponents and software-level components. The hardware-level componentsinclude one or more physical machines, such as physical machine 120 andphysical machine 130. The physical machine 120 includes a networkinterface 121, processor 122, memory 123, and disk 124 all incommunication with each other. Processor 122 allows physical machine 120to execute computer readable instructions stored in memory 123 toperform processes described herein. Disk 124 may include a hard diskdrive and/or a solid-state drive. The physical machine 130 includes anetwork interface 131, processor 132, memory 133, and disk 134 all incommunication with each other. Processor 132 allows physical machine 130to execute computer readable instructions stored in memory 133 toperform processes described herein. Disk 134 may include a hard diskdrive and/or a solid-state drive. In some cases, disk 134 may include aflash-based SSD or a hybrid HDD/SSD drive. In one embodiment, thestorage appliance 170 may include a plurality of physical machinesarranged in a cluster (e.g., eight machines in a cluster). Each of theplurality of physical machines may include a plurality of multi-coreCPUs, 128 GB of RAM, a 500 GB SSD, four 4 TB HDDs, and a networkinterface controller.

In some embodiments, the plurality of physical machines may be used toimplement a cluster-based network fileserver. The cluster-based networkfile server may neither require nor use a front-end load balancer. Oneissue with using a front-end load balancer to host the IP address forthe cluster-based network file server and to forward requests to thenodes of the cluster-based network file server is that the front-endload balancer comprises a single point of failure for the cluster-basednetwork file server. In some cases, the file system protocol used by aserver, such as server 160 in FIG. 1, or a hypervisor, such ashypervisor 186 in FIG. 2, to communicate with the storage appliance 170may not provide a failover mechanism (e.g., NFS Version 3). In the casethat no failover mechanism is provided on the client side, thehypervisor may not be able to connect to a new node within a cluster inthe event that the node connected to the hypervisor fails.

In some embodiments, each node in a cluster may be connected to eachother via a network and may be associated with one or more IP addresses(e.g., two different IP addresses may be assigned to each node). In oneexample, each node in the cluster may be assigned a permanent IP addressand a floating IP address and may be accessed using either the permanentIP address or the floating IP address. In this case, a hypervisor, suchas hypervisor 186 in FIG. 2 may be configured with a first floating IPaddress associated with a first node in the cluster. The hypervisor mayconnect to the cluster using the first floating IP address. In oneexample, the hypervisor may communicate with the cluster using the NFSVersion 3 protocol. Each node in the cluster may run a Virtual RouterRedundancy Protocol (VRRP) daemon. A daemon may comprise a backgroundprocess. Each VRRP daemon may include a list of all floating IPaddresses available within the cluster. In the event that the first nodeassociated with the first floating IP address fails, one of the VRRPdaemons may automatically assume or pick up the first floating IPaddress if no other VRRP daemon has already assumed the first floatingIP address. Therefore, if the first node in the cluster fails orotherwise goes down, then one of the remaining VRRP daemons running onthe other nodes in the cluster may assume the first floating IP addressthat is used by the hypervisor for communicating with the cluster.

In order to determine which of the other nodes in the cluster willassume the first floating IP address, a VRRP priority may beestablished. In one example, given a number (N) of nodes in a clusterfrom node(0) to node(N−1), for a floating IP address (i), the VRRPpriority of nodeG) may be G-i) modulo N. In another example, given anumber (N) of nodes in a cluster from node(0) to node(N−1), for afloating IP address (i), the VRRP priority of nodeG) may be (i-j) moduloN. In these cases, nodeG) will assume floating IP address (i) only ifits VRRP priority is higher than that of any other node in the clusterthat is alive and announcing itself on the network. Thus, if a nodefails, then there may be a clear priority ordering for determining whichother node in the cluster will take over the failed node's floating IPaddress.

In some cases, a cluster may include a plurality of nodes and each nodeof the plurality of nodes may be assigned a different floating IPaddress. In this case, a first hypervisor may be configured with a firstfloating IP address associated with a first node in the cluster, asecond hypervisor may be configured with a second floating IP addressassociated with a second node in the cluster, and a third hypervisor maybe configured with a third floating IP address associated with a thirdnode in the cluster.

As depicted in FIG. 3, the software-level components of the storageappliance 170 may include data management system 102, a virtualizationinterface 104, a distributed job scheduler 108, a distributed metadatastore 110, a distributed file system 112, and one or more virtualmachine search indexes, such as virtual machine search index 106. In oneembodiment, the software-level components of the storage appliance 170may be run using a dedicated hardware-based appliance. In anotherembodiment, the software-level components of the storage appliance 170may be run from the cloud (e.g., the software-level components may beinstalled on a cloud service provider).

In some cases, the data storage across a plurality of nodes in a cluster(e.g., the data storage available from the one or more physicalmachines) may be aggregated and made available over a single file systemnamespace (e.g., /snapshots/). A directory for each virtual machineprotected using the storage appliance 170 may be created (e.g., thedirectory for Virtual Machine A may be /snapshots/VM_A). Snapshots andother data associated with a virtual machine may reside within thedirectory for the virtual machine. In one example, snapshots of avirtual machine may be stored in subdirectories of the directory (e.g.,a first snapshot of Virtual Machine A may reside in/snapshots/VM_A/s1/and a second snapshot of Virtual Machine A may residein/snapshots/VM_A/s2/).

The distributed file system 112 may present itself as a single filesystem, in which as new physical machines or nodes are added to thestorage appliance 170, the cluster may automatically discover theadditional nodes and automatically increase the available capacity ofthe file system for storing files and other data. Each file stored inthe distributed file system 112 may be partitioned into one or morechunks or shards. Each of the one or more chunks may be stored withinthe distributed file system 112 as a separate file. The files storedwithin the distributed file system 112 may be replicated or mirroredover a plurality of physical machines, thereby creating a load-balancedand fault tolerant distributed file system. In one example, storageappliance 170 may include ten physical machines arranged as a failovercluster and a first file corresponding with a snapshot of a virtualmachine (e.g., /snapshots/VM_A/s1/s1.full) may be replicated and storedon three of the ten machines.

The distributed metadata store 110 may include a distributed databasemanagement system that provides high availability without a single pointof failure. In one embodiment, the distributed metadata store 110 maycomprise a database, such as a distributed document-oriented database.The distributed metadata store 110 may be used as a distributed keyvalue storage system. In one example, the distributed metadata store 110may comprise a distributed NoSQL key value store database. In somecases, the distributed metadata store 110 may include a partitioned rowstore, in which rows are organized into tables or other collections ofrelated data held within a structured format within the key value storedatabase. A table (or a set of tables) may be used to store metadatainformation associated with one or more files stored within thedistributed file system 112. The metadata information may include thename of a file, a size of the file, file permissions associated with thefile, when the file was last modified, and file mapping informationassociated with an identification of the location of the file storedwithin a cluster of physical machines. In one embodiment, a new filecorresponding with a snapshot of a virtual machine may be stored withinthe distributed file system 112 and metadata associated with the newfile may be stored within the distributed metadata store 110. Thedistributed metadata store 110 may also be used to store a backupschedule for the virtual machine and a list of snapshots for the virtualmachine that are stored using the storage appliance 170.

In some cases, the distributed metadata store 110 may be used to manageone or more versions of a virtual machine. Each version of the virtualmachine may correspond with a full image snapshot of the virtual machinestored within the distributed file system 112 or an incremental snapshotof the virtual machine (e.g., a forward incremental or reverseincremental) stored within the distributed file system 112. In oneembodiment, the one or more versions of the virtual machine maycorrespond with a plurality of files. The plurality of files may includea single full image snapshot of the virtual machine and one or moreincremental aspects derived from the single full image snapshot. Thesingle full image snapshot of the virtual machine may be stored using afirst storage device of a first type (e.g., an HDD) and the one or moreincremental aspects derived from the single full image snapshot may bestored using a second storage device of a second type (e.g., an SSD). Inthis case, only a single full image needs to be stored and each versionof the virtual machine may be generated from the single full image orthe single full image combined with a subset of the one or moreincremental aspects. Furthermore, each version of the virtual machinemay be generated by performing a sequential read from the first storagedevice (e.g., reading a single file from an HDD) to acquire the fullimage and, in parallel, performing one or more reads from the secondstorage device (e.g., performing fast random reads from an SSD) toacquire the one or more incremental aspects.

The distributed job scheduler 108 may be used for scheduling backup jobsthat acquire and store virtual machine snapshots for one or more virtualmachines over time. The distributed job scheduler 108 may follow abackup schedule to backup an entire image of a virtual machine at aparticular point in time or one or more virtual disks associated withthe virtual machine at the particular point in time. In one example, thebackup schedule may specify that the virtual machine be backed up at asnapshot capture frequency, such as every two hours or every 24 hours.Each backup job may be associated with one or more tasks to be performedin a sequence. Each of the one or more tasks associated with a job maybe run on a particular node within a cluster. In some cases, thedistributed job scheduler 108 may schedule a specific job to be run on aparticular node based on data stored on the particular node. Forexample, the distributed job scheduler 108 may schedule a virtualmachine snapshot job to be run on a node in a cluster that is used tostore snapshots of the virtual machine in order to reduce networkcongestion.

The distributed job scheduler 108 may comprise a distributed faulttolerant job scheduler, in which jobs affected by node failures arerecovered and rescheduled to be run on available nodes. In oneembodiment, the distributed job scheduler 108 may be fully decentralizedand implemented without the existence of a master node. The distributedjob scheduler 108 may run job scheduling processes on each node in acluster or on a plurality of nodes in the cluster. In one example, thedistributed job scheduler 108 may run a first set of job schedulingprocesses on a first node in the cluster, a second set of job schedulingprocesses on a second node in the cluster, and a third set of jobscheduling processes on a third node in the cluster. The first set ofjob scheduling processes, the second set of job scheduling processes,and the third set of job scheduling processes may store informationregarding jobs, schedules, and the states of jobs using a metadatastore, such as distributed metadata store 110. In the event that thefirst node running the first set of job scheduling processes fails(e.g., due to a network failure or a physical machine failure), thestates of the jobs managed by the first set of job scheduling processesmay fail to be updated within a threshold period of time (e.g., a jobmay fail to be completed within 30 seconds or within minutes from beingstarted). In response to detecting jobs that have failed to be updatedwithin the threshold period of time, the distributed job scheduler 108may undo and restart the failed jobs on available nodes within thecluster.

The job scheduling processes running on at least a plurality of nodes ina cluster (e.g., on each available node in the cluster) may manage thescheduling and execution of a plurality of jobs. The job schedulingprocesses may include run processes for running jobs, cleanup processesfor cleaning up failed tasks, and rollback processes for rolling-back orundoing any actions or tasks performed by failed jobs. In oneembodiment, the job scheduling processes may detect that a particulartask for a particular job has failed and in response may perform acleanup process to clean up or remove the effects of the particular taskand then perform a rollback process that processes one or more completedtasks for the particular job in reverse order to undo the effects of theone or more completed tasks. Once the particular job with the failedtask has been undone, the job scheduling processes may restart theparticular job on an available node in the cluster.

The distributed job scheduler 108 may manage a job in which a series oftasks associated with the job are to be performed atomically (i.e.,partial execution of the series of tasks is not permitted). If theseries of tasks cannot be completely executed or there is any failurethat occurs to one of the series of tasks during execution (e.g., a harddisk associated with a physical machine fails or a network connection tothe physical machine fails), then the state of a data management systemmay be returned to a state as if none of the series of tasks were everperformed. The series of tasks may correspond with an ordering of tasksfor the series of tasks and the distributed job scheduler 108 may ensurethat each task of the series of tasks is executed based on the orderingof tasks. Tasks that do not have dependencies with each other may beexecuted in parallel.

In some cases, the distributed job scheduler 108 may schedule each taskof a series of tasks to be performed on a specific node in a cluster. Inother cases, the distributed job scheduler 108 may schedule a first taskof the series of tasks to be performed on a first node in a cluster anda second task of the series of tasks to be performed on a second node inthe cluster. In these cases, the first task may have to operate on afirst set of data (e.g., a first file stored in a file system) stored onthe first node and the second task may have to operate on a second setof data (e.g., metadata related to the first file that is stored in adatabase) stored on the second node. In some embodiments, one or moretasks associated 20 with a job may have an affinity to a specific nodein a cluster.

In one example, if the one or more tasks require access to a databasethat has been replicated on three nodes in a cluster, then the one ormore tasks may be executed on one of the three nodes. In anotherexample, if the one or more tasks require access to multiple chunks ofdata associated with a virtual disk that has been replicated over fournodes in a cluster, then the one or more tasks may be executed on one ofthe four nodes. Thus, the distributed job scheduler 108 may assign oneor more tasks associated with a job to be 30 executed on a particularnode in a cluster based on the location of data required to be accessedby the one or more tasks.

In one embodiment, the distributed job scheduler 108 may manage a firstjob associated with capturing and storing a snapshot of a virtualmachine periodically (e.g., every 30 minutes). The first job may includeone or more tasks, such as communicating with a virtualizedinfrastructure manager, such as the virtualized infrastructure manager199 in FIG. 2, to create a frozen copy of the virtual machine and totransfer one or more chunks (or one or more files) associated with thefrozen copy to a storage appliance, such as storage appliance 170 inFIG. 1. The one or more tasks may also include generating metadata forthe one or more chunks, storing the metadata using the distributedmetadata store 110, storing the one or more chunks within thedistributed file system 112, and communicating with the virtualizedinfrastructure manager that the virtual machine the frozen copy of thevirtual machine may be unfrozen or released for a frozen state. Themetadata for a first chunk of the one or more chunks may includeinformation specifying a version of the virtual machine associated withthe frozen copy, a time associated with the version (e.g., the snapshotof the virtual machine was taken at 5:30 p.m. on Jun. 29, 2018), and afile path to where the first chunk is stored within the distributed filesystem 112 (e.g., the first chunk is located at/snapshotsNM_B/s1/s1.chunk1). The one or more tasks may also includededuplication, compression (e.g., using a lossless data compressionalgorithm such as LZ4 or LZ77), decompression, encryption (e.g., using asymmetric key algorithm such as Triple DES or AES-256), and decryptionrelated tasks.

The virtualization interface 104 may provide an interface forcommunicating with a virtualized infrastructure manager managing avirtualization infrastructure, such as virtualized infrastructuremanager 199 in FIG. 2, and requesting data associated with virtualmachine snapshots from the virtualization infrastructure. Thevirtualization interface 104 may communicate with the virtualizedinfrastructure manager using an API for accessing the virtualizedinfrastructure manager (e.g., to communicate a request for a snapshot ofa virtual machine). In this case, storage appliance 170 may request andreceive data from a virtualized infrastructure without requiring agentsoftware to be installed or running on virtual machines within thevirtualized infrastructure. The virtualization interface 104 may requestdata associated with virtual blocks stored on a virtual disk of thevirtual machine that have changed since a last snapshot of the virtualmachine was taken or since a specified prior point in time. Therefore,in some cases, if a snapshot of a virtual machine is the first snapshottaken of the virtual machine, then a full image of the virtual machinemay be transferred to the storage appliance. However, if the snapshot ofthe virtual machine is not the first snapshot taken of the virtualmachine, then only the data blocks of the virtual machine that havechanged since a prior snapshot was taken may be transferred to thestorage appliance.

The virtual machine search index 106 may include a list of files thathave been stored using a virtual machine and a version history for eachof the files in the list. Each version of a file may be mapped to theearliest point in time snapshot of the virtual machine that includes theversion of the file or to a snapshot of the virtual machine that includethe version of the file (e.g., the latest point in time snapshot of thevirtual machine that includes the version of the file). In one example,the virtual machine search index 106 may be used to identify a versionof the virtual machine that includes a particular version of a file(e.g., a particular version of a database, a spreadsheet, or a wordprocessing document). In some cases, each of the virtual machines thatare backed up or protected using storage appliance 170 may have acorresponding virtual machine search index.

In one embodiment, as each snapshot of a virtual machine is ingestedeach virtual disk associated with the virtual machine is parsed in orderto identify a file system type associated with the virtual disk and toextract metadata (e.g., file system metadata) for each file stored onthe virtual disk. The metadata may include information for locating andretrieving each file from the virtual disk. The metadata may alsoinclude a name of a file, the size of the file, the last time at whichthe file was modified, and a content checksum for the file. Each filethat has been added, deleted, or modified since a previous snapshot wascaptured may be determined using the metadata (e.g., by comparing thetime at which a file was last modified with a time associated with theprevious snapshot). Thus, for every file that has existed within any ofthe snapshots of the virtual machine, a virtual machine search index maybe used to identify when the file was first created (e.g., correspondingwith a first version of the file) and at what times the file wasmodified (e.g., corresponding with subsequent versions of the file).Each version of the file may be mapped to a particular version of thevirtual machine that stores that version of the file.

In some cases, if a virtual machine includes a plurality of virtualdisks, then a virtual machine search index may be generated for eachvirtual disk of the plurality of virtual disks. For example, a firstvirtual machine search index may catalog and map files located on afirst virtual disk of the plurality of virtual disks and a secondvirtual machine search index may catalog and map files located on asecond virtual disk of the plurality of virtual disks. In this case, aglobal file catalog or a global virtual machine search index for thevirtual machine may include the first virtual machine search index andthe second virtual machine search index. A global file catalog may bestored for each virtual machine backed up by a storage appliance withina file system, such as distributed file system 112 in FIG. 3.

The data management system 102 may comprise an application running onthe storage appliance that manages and stores one or more snapshots of avirtual machine. In one example, the data management system 102 maycomprise a highest-level layer in an integrated software stack runningon the storage appliance. The integrated software stack may include thedata management system 102, the virtualization interface 104, thedistributed job scheduler 108, the distributed metadata store 110, andthe distributed file system 112.

In some cases, the integrated software stack may run on other computingdevices, such as a server or computing device 154 in FIG. 1. The datamanagement system 102 may use the virtualization interface 104, thedistributed job scheduler 108, the distributed metadata store 110, andthe distributed file system 112 to manage and store one or moresnapshots of a virtual machine. Each snapshot of the virtual machine maycorrespond with a point in time version of the virtual machine. The datamanagement system 102 may generate and manage a list of versions for thevirtual machine. Each version of the virtual machine may map to orreference one or more chunks and/or one or more files stored within thedistributed file system 112. Combined together, the one or more chunksand/or the one or more files stored within the distributed file system112 may comprise a full image of the version of the virtual machine.

Aspects of the present disclosure may be used in conjunction with asnapshot-based approach. With reference to FIG. 4, in a networkedenvironment 400 a base snapshot 402 may be taken for example when aprotection policy (e.g. under a Service Level Agreement) is enabled on aVM 404 and its virtual disks. After the base snapshot 402 is saved on abackup site 406, incremental snapshots 408 are taken periodically. Adelta 410 between the two snapshots 402 and 408 represents data blocksthat have changed, and these blocks 412 may be sent to and stored on thebackup site 406 for recovery when needed. Since taking snapshots may bean expensive operation and can impact users, snapshots are typicallytaken some minutes apart, often from the tens of minutes to severalhours and without certain techniques discussed herein this can result ina poor RPO.

In some instances, taking snapshots may involve relatively heavyoperations performed on a periodic basis, perhaps several hours apartand then replicated to data recovery (DR) locations. Thesesnapshot-based solutions typically meet data protection needs forapplications where the service level objectives can accommodate hours ofdata loss in the event of disaster. However, for other applicationsthere is a requirement to reduce the potential loss to minutes, or evenseconds, of data loss. Snapshot-based solutions cannot typically scaleto meet these aggressive requirements, and users may be obliged to adoptalternate methods such as replication at the application, database,storage, or hypervisor level.

Some examples herein seek to address this gap by delivering a continuousdata protection capability enabling users to protect, for example, highvalue applications and deliver near-zero RPOs. Users may still enjoy anear seamless experience in integrating with traditional “discrete”snapshots, extending existing services such as SLA domains, transportmodels for archival sites in the cloud or on premises (on prem), globalsearching, and recovery models.

With reference to FIG. 5 which shows a timeline of an example use case,a virtualization administrator may for example accidentally delete a VMat the illustrated “disaster point”. The administrator may wish torestore that VM locally from the latest point in time prior to deletionof the VM. With a snapshot-based approach the recoverable data may beseveral hours old, as shown for example at the illustrated “lastsnapshot”. Some examples herein provide continuous data protection (CDP)allowing data recovery from an RPO point a few moments ago, as shown forexample at the illustrated “recovery point”. The term continuous dataprotection herein means “near-continuous” or “substantially” continuous,providing in some instances an RPO of less than a minute (60 seconds).Longer RPO's in the range of 1 to 5 minutes are possible using thedisclosed techniques. Ideally, an RPO will exist only a few secondsbefore the VM was deleted. Similarly, in the case of a storage failureat a local data center, by using the techniques described herein someexamples allow the recovery of multiple VMs remotely from the mostrecent version of the data which may only be a few seconds old.

With reference to FIG. 6, in another example a backup administrator maywish to recover from a breakdown, at a local or remote site, from anhistorical point in time closest to the point prior to when thebreakdown was detected. Say, for example, a data corruption occurs at a“corruption point” and is only detected sometime later at a “corruptiondetected” point, a snapshot-based approach would only allow recoveryfrom an uncorrupted snapshot existing prior to the corruption point. Acorrupted snapshot taken after the corruption is not a viable recoverypoint even if it was taken before the corruption was detected. A recentviable uncorrupted snapshot may not exist, in fact a viable snapshot mayonly exist several hours or, in extreme cases, days ago. Examples of thepresent disclosure allow for a recovery point “just before” (i.e. an RPOof near-zero) the corruption point.

With reference to FIG. 7, in a networked environment 700, in someexamples virtual disk I/Os that are exchanged between a virtual machine(VM) 704 and a virtualization server, for example an ESX (hypervisor)server 706, are intercepted at an I/O stack 710 in an I/O path 702. TheI/O interception and stack allows the I/O to be replicated at 708 to abackup site (or log receiver) 712 at near real time. This may be donewith minimal user impact. The I/O replication may in some examplessubstantially eliminate a need to take snapshots periodically. RPO maybe reduced down to seconds. I/O logs 714, discussed further below, arecreated.

More specifically, in some examples, I/Os are intercepted in an I/O pathand allow the collection and replication of changed data. When an I/O isrequested for example at 718, it goes through the ESX's I/O stack 710and the I/O can be intercepted and replicated to a backup site 712. Thereplicated I/Os are stored in logs 714 which can be used for recovery byapplying the I/Os on top of a base snapshot 716. Because the I/Os areintercepted and replicated while the I/Os are going through the I/Ostack 710, there is a minimal delay before the I/O reaches the backupsite 712, and RPO is reduced significantly. A filter framework, such asa VAIO filter framework for example (see FIG. 8), may allow minimal userimpact by inserting a filter driver inside the ESX server 706 tointercept and replicate the I/Os.

With reference to FIG. 8, a networked environment 800 includes a virtualmachine (VM) 802, an ESX server 804, and a backup site 806. The ESXserver 804 includes an I/O stack 808 and an I/O filter 810. The I/Ofilter 810 (also known as a replication filter, or plugin filter) mayinclude a plugin filter driver to intercept I/Os for the purpose ofcaching and replication. An example replication method may include theI/O operations 1-6 as indicated. The illustrated filter framework can,in some examples, provide one or more touch-points during an I/O's lifecycle, for example start, cancel, complete, and so forth. A filterdriver can in some examples be configured to intercept an I/O at anypoint. For efficiency reasons for example, a filter may be configured tointercept only completed I/Os and may significantly reduce thecomplexity of managing the life cycle of I/Os accordingly. The labeledarrows in FIG. 8 represent an example workflow of a replication filter.

Some examples address replication complications that may arise from I/Ocancellations. Replication can become more challenging and complicatedif an I/O cancellation occurs. In the networked example 900 of FIG. 9,both of the I/O filter driver 910 and backup site 906 may require anability to handle cancelled I/O's. A distributed I/O cancellation iscomplicated and leaves much room for error and data recoveryunreliability. To address complications arising in such animplementation, a replication method may include the I/O operationsillustrated in FIG. 9. In some examples, instead of replicating I/Os atan I/O start (i.e. a selected touch-point mentioned above), I/Os are insome examples replicated at an I/O completion (another selectedtouch-point mentioned above). A I/O cancellation occurring between anI/O start and an I/O completion is thus rendered moot. In some examples,the use of I/O data collection (as opposed to snapshots) and the abilityof the filter framework to select a touchpoint for data collectionallows complicated I/O cancellation ordinarily handling by the filterdriver and backup site to be eliminated.

With reference to another example networked configuration 1000 in FIG.10, I/O cancellation is managed by the I/O stack 1008 of the ESX server1004 and is not populated to the I/O filter 1010. A replication methodmay include the I/O operations as shown.

Thus, in some examples, an I/O based recovery enables an optimized RPO.A filter framework enables tap off of I/O data at an ESX server (orhypervisor) between a VM and production storage. I/O data is obtainedwithout affecting production latency. A filter touchpoint selectionallows selection of various I/O touch-points to configure I/Ocollection. This enables a parsing of various portions of I/O data,instead of having to process full I/O stream. A specific touch-pointselection of completed I/O's addresses the problem of how to handledistributed I/O cancellations. By replicating at I/O completion, priorI/O cancellations are rendered moot.

In some examples, a cache or buffer 722 (FIG. 7) may be provided betweenan ESX server (e.g. ESX server 706, 804, 904, or 1004) and a backup siteor log receiver (e.g. backup site 712, 806, 906, or 1006). I/O data caninclude blocky chunks of data, some of very large size. This canoverwhelm resources at a backup site. A cache smooths out the I/O dataflow and enables use of existing resources at a “snapshot” backup site.In some examples, two (or more) caches are provided, for example anetwork cache and a backup site (or log receiver) cache 720 (FIG. 7). Insome instances, a single cache may be overwhelmed at extreme I/O flow. Anetwork cache and a backup site cache work in tandem to smooth I/O flowto the backup site (receiver).

In some examples, some or all of the I/O data is replicated directly tomemory, not to disk as handling massive I/O data can be a challenge. Insome examples, the I/O data remains in memory until it is replicated, orthe I/O data may be replicated directly from memory. In some examples,sequence numbers are added to the I/O data write and/or read paths todetect 110 data gaps, corruption, and so forth. The monitoring ofconsecutive sequence numbers may allow a confirmation that full I/O datawas sent and received. This check can be done and supplemented beforemounting so that only good data is used and/or replicated.

Some example filter frameworks include a timestamp module, and an offsetmodule. Reconciling an ESX server timestamp (collection point) with abackup site (recovery) Rubrik timestamp can be challenging. A large datablock remount can be difficult in timestamp offset situations, and thetimestamp and offset modules are configured to calculate and adjust forthis difference. This ability may in turn enable a convenient RPOselection for example by depicting a slider bar in a graphical userinterface (GUI) and enable successful large data block remounts based onslider selection, notwithstanding a timestamp offset between an ESXserver and a backup site. Some examples may include a timestamp journaland index to identify a correct RPO point, and a near-zero RPO bypointing in real-time to an offset and enabling the correct data to beread at a precise moment it is need.

The management of the I/O stream and the I/O logs 714 at the backup site712 (see, for example FIG. 7) is now described more fully. In someembodiments, in addition to taking snapshots, a continuous dataprotection (CDP) system maintains I/O logs for virtual machines. Someexamples enable point in time recovery by replaying logs on top of abase snapshot. In some examples, a sub-minute (i.e. less than 60seconds) recovery point objective (RPO) is achieved assuming sufficientnetwork bandwidth. Occasionally, replication of a base snapshot may beabsent or delayed. In a catchup situation, newer logs in multiple logson top of a base snapshot may be prioritized for replay.

With reference again to FIG. 8, a filter (for example a VAIO filter) 810sends I/Os to a log receiver (e.g. a backup site 806, or a CDP service)using for example code division multiplexing CDM. CDM is a networkingtechnique in which multiple data signals are combined for simultaneoustransmission over a common frequency band. The log receiver buffers thereceived I/O's in memory and periodically (based on a time/buffer sizethreshold) flushes them to a log file. A log file may be included in anI/O log 714 (FIG. 7), on top of a base snapshot 716 (FIG. 7). The logs714 roll over in the event of a new snapshot, time, or size-basedthreshold. Some examples replicate these logs to a replication target.In order to support optimum (low) RPOs, data is replicated as soon as itreceived. Thus, in some examples, a push-based replication approach isutilized, as opposed to pull-based models.

As mentioned above, example embodiments may include a network buffer 722and/or a log receiver buffer 720. A buffer 720 allows a log receiver 712to queue the I/Os to create a fast path for logs to replicated assumingthere is sufficient network bandwidth. If a required log sequence is notin the buffer 722, the log receiver 712 reads sequentially from diskuntil a catchup. In some examples, a catchup may include reading amissing portion of records from a disk without necessarily reading allthe way to the end of disk as the log receiver 712 has filled up the gapbetween two logs in the memory records. A source component at the logreceiver may ensure that records are received by a replication target(e.g. a database, a backup site, or a VM requiring backup data) andschedule flushes of the records to a log file on disk in order. Logs atthe source component and the replication target maintain a one to onemapping. This implies a given log on source will either not bereplicated at all or will be replicated completely to the replicationtarget with the same logId.

With reference to FIG. 11, an example log receiver 1102 resides in anetworked environment 1100. A log receiver (also termed a backup site,or log receiver service herein) may provide certain services and include(or interact with) a log replication sender 1104, a log replicationreceiver 1106, and a CDP metadata service 1108. In some examples, thelog replication sender 1104 runs on a data or I/O source component andis responsible for sending data from the source component to one of morereplication targets. In some examples, the log replication sender 1104resides in a log receiver data service. The log replication sender 1104can communicate at 1110 directly to a log replication receiver 1106residing at a replication target. In some examples, the log replicationsender 1104 and the log replication receiver 1106 are on differentnodes. For each node of a source cluster, the log replication sender1104 communicates with the log replication receiver 1104 on that nodeand the CDP metadata service 1108 on that source node. For each node ofa target cluster, the log replication receiver 1104 communicates withthe CDP metadata service 1108 on that target node.

In some examples, the log replication receiver 1106 runs at areplication target and in some examples resides in an existingreplication service (e.g. a snapshot replication service). This mayprovide some convenience in that a client may not be required to performadditional configuration for CDP replication as the same ports may beused and network address translation (NAT) configuration may becontinued. The log replication receiver 1106 is responsible forreceiving data from the log replication sender and adding it to a logfile (e.g. an I/O log 714 in FIG. 7). Some arrangements include aseparate log replication receiver 1106 and send proxy requests throughan existing snapshot replication service. Proxying can increase overallmemory requirements as the same amount of memory would be required onboth the log replication sender 1104 and log replication receiver 1106at steady state data transfer. In some examples, the CDP metadataservice 1108 runs on both the data source component and the replicationtarget. The log replication sender 1104 and the log replication receiver1106 communicate with the CDP metadata service for all metadataoperations.

In some examples, the log replication sender 1104 includes a metadataservice component responsible for metadata operations and a data servicecomponent responsible for data transfer. The data service componentcalls an application programming interface (API) such as a writeToLogAPI on the log replication receiver 1106 to replicate records. The logfile to be replicated may be a closed file or an open file currentlyreceiving data records from an I/O filter (e.g. I/O filter 810 in FIG.8). In the case of closed replication, records (I/O data) are read fromthe log file on disk and replicated. In the case of live replication, itis not necessary to read the records from disk but instead directlyreplicate the records received from the I/O filter 810 by using anin-memory buffer. In some examples, this may be performed as follows.

The log receiver 1102 receives records (I/O data) from the I/O filter810, stores the records in memory (e.g. I/O logs 714), and then flushesthe logs to a distributed or scale data file system periodically. Oncethe records are flushed, the log receiver 1102 calls a live replicatormanager to perform live replication before the log receiver 1104 removesthe flushed records out of its memory. The log receiver 1102 instructsthe live replication manager to replicate records [for example, recordsm, n]. The live replication manager checks its own memory usage and ifthe combined size of the records (m, n) fits into the memory of the livereplication manager, the live replication manager moves the receivedrecords to its own memory and queues a replicate request to a livereplicator worker and indicates the records are in memory. If thereceived records do not fit into its memory, the live replicator managerwill ignore the records and queue a replicate request to the livereplicator worker and indicate that the records are on disk. The livereplicator worker reads a replicate request from the queue. If therecords are in memory, it reads the records from memory and sends themto the log replication receiver 1106 and removes the records from memoryto free up space. If the replicate request indicates that the recordsare on disk, it will read from SDFS, then replicate to the logreplication receiver 1106.

Certain APIs may be used in conjunction with the log replication sender1104. A replicateLog API is used for replication which may be closed, orlive replication as discussed above. Once all the records for a givenlog are replicated, the log replication sender 1104 calls asignalReplicateLogCompletion API on the metadata service component. AreplicateLogStatus API is used to check the status of the replicationwhich is ultimately reported on a graphical user interface (GUI) as aremote recovery point (e.g. a GUI on a physical machine 120 or 130 ofFIG. 3).

In some examples, the log replication receiver 1106 comprises orprovides a thrift service on a target cluster (e.g. a cluster discussedwith reference to FIGS. 1-3 above) that is responsible for receivinglogs sent by the log replication sender 1104. In some instances, the logreplication sender 1106 may try to replicate or send the same logmultiple times in case of crashes, lost acknowledgments, and so forth.The log replication receiver 1106 is responsible for dealing withduplicate data. In some examples, the log replication receiver 1106maintains an in-memory handleId to generate a disk-id map which ispopulated on each openLog call by the log replication sender 1104. Ifthe log replication receiver 1106 receives a call without a validhandleId, it generates an error.

Certain APIs may be used in conjunction with the log replicationreceiver 1106. An openLog API determines the node on which a disk shouldreplicate using round robin or random assignment techniques for loadbalancing. The API may generate a unique handleId which is used in allsubsequent requests by the source. The API may review a log table todetermine a last replicated log. In the event of source side crash, apreviously assigned node id should exist for the disk, accordingly. Insome cases, there may be a partially replicated log. The log content ofthe partially replicated log is deleted, and the replication startsafresh. A resumability (i.e. an ability to resume) function may beestablished at this point. A call to a writeToLog API contains a list ofrequested records for replication and the requested records are queuedto an in-memory buffer. In some examples, the records are flushed to thedisk in-order by a daemon (background process). If the in-memory bufferis full because it is holding out of order records, then the APIresponds with a sequence_out_of_order status. At this point, the logreplication sender 1104 may retry starting from the last record receivedin-order. A closeLog API is utilized when the log replication sender1104 has sent all the records for a given log. The log replicationsender 1104 then it sends closeLog request to signal the end of the log.At this point, the log replication sender may call a finishCreate logstore API.

In some examples, the CDP metadata service 1108 scans disks in an I/Ostream source table periodically to determine and claim a replicationowner node for a disk. Each disk (or I/O stream source) has areplicationOwnerId to ensure that only one node is working onreplicating logs for that disk at a time. This operation may include aworker pool which processes each disk that is seeking replication fromthe relevant node. In some examples, a worker claims replicationownership for the node to ensure only one node is replicating for adisk. The worker determines the next log to be replicated by calling areplication orchestrator, discussed in more detail below. The workergenerates a unique handleId for each log replication which is used inall API requests. In some examples, the worker calls an openLog API ofthe replication target to initialize log replication with the uniquehandleId, and a replicateLog API of a data service on the relevant nodewith the log information, the handleId, and targetNode information whichdoes the replication of data records. A signalReplicateLogCompletion APIis called by the data service once it finishes replicating all therequested records. This API may call a finalizeLog API of thereplication target which marks the log as finalized on the target. Areplication status of the log on the source may be changed to areplicated status accordingly.

Some embodiments include an algorithm to filter disks (e.g. VM disks bythe I/O filter 810, FIG. 8) and determine a replication owner node. Fordisks which receive I/O records from the I/O filter 810 and replicationis enabled (e.g. an effective service level agreement (SLA) hasreplication enabled), the replication owner is same as the log receiver1102 owner. This enables a read from the log receiver 1102 buffer (e.g.buffer 720, FIG. 7) and creates a fast path of data transfer whenreplication can keep up with the incoming I/O stream (e.g. I/O stream708, FIG. 7). This configuration also allows the use of the same loadbalancing as used by the log receiver 1102 even when log replicationlags behind. For disks which have no assigned log receiver owner(implying the disk is not receiving I/O records), but for which logreplication is enabled, node ownership is claimed based on a shardingtechnique so that these disks can be distributed equally among thesource nodes.

Some embodiments include a replication status poller. The metadataservice of the log replication sender 1104 maintains an in-memory queuecontaining handleIds of logs that are replicating from the relevantnode. The poller is responsible for determining a timestamp of a lastreplicated data record. The timestamp is used for remote recovery pointcalculation, cleanup in the event of a service restart, or other unknownfailures.

In some examples, the poller periodically (for example, every 30seconds) calls an API (for example, replicateLogStatus(handleId) API) toidentify the timestamp of the last replicated data record and persistthis information in a database. This information may be stored forexample as diskId->(current replicating log id, timestamp of lastreplicate data record, lastUpdateTime). This information may serve tocompute a remote recovery point. In some examples, the database does notupdate if the data service is down or if it is not replicating any datawith respect to handleIds generally, or the specific handleId. If thelastUpdateTime is more than 30 minutes ago (for example), the pollerconcludes that something is amiss as the log is not being replicated. Anext step may include performing a cleanup operation of the session withrespect to the relevant handleId and then restart replication for thedisk. In some examples, cleanup is performed done by calling a deleteLogAPI for (handle_id, log_id).

A unique handle identification (handleId) may be important in someembodiments. For example, a unique handleId is used for an initialhandshake (using the openLog API) to establish all replication requestswith respect to a given log being sent by the applicable uniquehandleId. There can only be one active handle identification for anydisk and a unique handleId is generated for each log replication. Usinga unique handleId may be important because replication requestscommunicated over a wide area network (WAN) can return a client error ortimeout status with respect to a data source but it is still executed onthe target. Further, if a previous finalizeLog API or deleteLog API fora given log is executed later on the target, this could lead toinconsistent state. But as each log is verified with respect to acurrent active handleId, these errors or inconsistent requests can beignored.

As discussed above, in some embodiments replicated I/Os are stored inlogs 714 which can be used for recovery by applying the I/Os on top of abase snapshot 716. Some present embodiments include a CDP replicationorchestrator to determine and prioritize base snapshots for replication(for example, base snapshot 716, FIG. 7), as opposed to other SLAsnapshots.

In some embodiments, an orchestrator accesses for replication at leastthe following information from a I/O stream log table: a logId; abase_log_id; a StreamSourceId or a vmwareDiskId; a replication statussuch as to_replicate (no work yet done on replicating a log),in_progress (a worker is currently replicating the log), or replicated(the log has been replicated to the target cluster); and a base snapshotidentification (for example, base snapshot 716, FIG. 7). In someembodiments, the orchestrator may also identify or access a streamsource including a StreamSourceId and replication metadata. Thereplication metadata may include a data store owner nodeId and aclaimTime value. A data store handle information may include a handleId,and a log id. Some embodiments also include a snapshot table accessed bythe orchestrator during replication operations. In some examples, asnapshot table may store dependent log information which may be readduring a pull replication or by an openLog API to add the base snapshotfor the log on the replication target.

With reference to FIG. 12, in some examples a CDP replicationorchestrator abstracts out at 1200 a snapshot-log chain using managementlogic for determining a next log for replication. Each snapshot-logchain 1200 starts from a snapshot 1202 followed by one or more logchains 1204 and 1206 for it to be recoverable i.e. capable ofreplication. The snapshot-log chain 1204 may relate to a disk 1, whilethe snapshot-log chain 1206 may relate to a disk 2. The replicationorchestrator is designed to keep track of these chains 1202 and 1204 tooversee an identification and replication of all the snapshots necessary(so-called “must-replicate” or “must-have” snapshots) for the log chainsto be recoverable on the replication target and, since a VM may containmultiple disks, a determination that the logs replicated for multipledisks are in sync with one another.

In some examples, the following APIs are exposed by the orchestrator. AGetNextLogToReplicate API returns the next I/O stream to be replicatedfor a given stream source id. The logic handles all the cases where thedisk might be lagging due to slow network connectivity or other reasons.Some examples try to start a chain from a new snapshot if a snapshotfalls outside of a retention window. The orchestrator also handles casesin which VM disks are added or removed from the VM inappropriately. AGetNextSnapshotToReplicate API is used by the orchestrator internally toensure that all “must-have” snapshots are not deleted until they arereplicated. A CalculateLastReplicatedTimeInNanos API assists indetermining a remote recovery point. The API factors into thisdetermination whether the snapshot is replicated and the last status ofthe inprogress log which is being replicated.

In some examples, the replication orchestrator also has thefunctionality to pick up inProgress snapshots and start replicatinglogs. In some examples, this is done optimistically in the sense thatthe orchestrator begins replicating 10 records with the hope that thesnapshot copy step will not fail. If it fails for some reason, then thelogs may have to be discarded. Snapshot completion or failure cases areappropriately handled. Specifically, in the case of failure, logs arenot replicated anymore and the chain (for example, chain 1202 or 1204)is marked invalid. In some embodiments, all operations to theorchestrator are performed atomically and are thread-safe. Some exampleembodiments begin collecting I/O records as soon as a ‘take snapshotAPI’ call to a virtual center for that virtual machine succeeds. Afterthis, the replication orchestrator copies the data onto a cluster whichcould take any amount of time based on size and change rates of thevirtual machine. In some examples, only when a snapshot is fully copiedon to the cluster do the I/O records become recoverable. It is alsopossible that there is some failure in the copy step. In a failure case,the snapshot is not available and hence I/O records beyond that snapshotcannot be used for recovery.

Some embodiments of a CDP replication orchestrator may include thefollowing design aspects and data structures. For example, data entriesin a replication orchestrator table may include a primary key andorchestrator information. A primary key may include a compositeidentification (compositeId) of a “snappable” i.e. a snapshot, (forexample, a “must-have” snapshot and a target cluster identification(targetClusterId). Orchestrator information may include a chain ofsnapshotAndLogInfo where each chain starts from a snapshot followed bylogs for each VM disk. This snapshot may be a “must-have” snapshot and,if so, will be replicated to make the logs recoverable on thereplication target. In some examples, a new chain is added to the liston various conditions: for example, a replication on a previous logchain falls out of a retention window for any of the VM disks, or a CDPeffort is broken on the source and is then restarted, or a replicationencounters an error (for example, a network error or other fault) whichresults in a log being marked with an error message, for exampleReplicatedWithError.

An example data structure may include I/O stream source information suchas streamLogIds (OrchestratorList), a doneReplication (Boolean value),and a lastUpdatedTimestamp (for example, Option[Date]=None). The datastructure may store a list of streamLogIds for each stream source.Usually the last log in this list is the one which is being replicatedor is the next candidate for replication. Some structures also store thelastUpdatedTimestamp to detect a last modification. Orchestrator rows orlists in the data structure may be checked to determine those which havenot been updated beyond a specified time and purged. Appropriate pruninglogic may be added to an orchestrator list so that a log chain does notgrow in an unbounded fashion. Unbounded chains could lead to bigmetadata rows and cause processing problems.

Snapshot and log information in an example data structure may includeone unit of a snapshot-log chain. Some example orchestrators include amechanism to start a log chain even from an in-progress snapshot. Themechanism may include or access a map from streamSource toStreamSourceInfo and assist in tracking how far each disk has beenreplicated. The mechanism may also store information to detect if thesnapshot needs to be pinned or not and if it has been replicated. Someexamples a background replication orchestrator which cleans up thereplication orchestrator table in a data structure. This clean up mayinclude removing archived snappable rows and all rows for which aservice level agreement (SLA) has changed to a different target cluster.All relevant snapshots are unpinned while removing the chain.

As mentioned above, some embodiments provide the ability for users toprotect their workloads and data at discrete points-in-time usingsnapshots. These snapshots are relatively heavy operations that areperformed on a periodic basis, perhaps several hours apart and thenreplicated to DR locations. Snapshot based solutions meet the dataprotection needs for applications where the service level objectives canaccommodate hours of data loss in the event of disaster. However, forother applications there is a requirement to reduce the potential lossto minutes, or even seconds, of data loss. Snapshot based solutionscannot scale to meet these aggressive requirements, and customers areforced to adopt additional solutions like replication at theapplication, database, storage, or hypervisor level. To address thisgap, some embodiments deliver a new near-continuous data protection(CDP) capability that enable users to protect, for example, high-valueapplications and deliver near-zero RPOs.

In this regard, to enable CDP, a vendor specific driver capturescontinuous I/Os, caches them, and sends the I/O data (a.k.a. “streamlogs”) to clusters. A log receiver service (LRS) running on nodesreceives the logs and write them to a disk. Logs are captured after asnapshot is taken. This snapshot will serve as the base of subsequentlogs. Logs are captured one after another, a later one depends on theformer one. Thus, with reference to FIG. 13, the continuous logs form alog chain 1300. The dotted arrows show the logical dependencies of thesnapshots and logs. A log chain is valid only if there is a basesnapshot. In other words, a VM is recoverable from a specific continuouspoint-in-time version (which corresponds to a log) only if there is avalid base snapshot. Once a new snapshot is taken and designated as thenew base, old logs may be eligible for expiration or garbage collectiondepending on the assigned SLA policy.

Typical operations supported by CDP includes obtaining or accessing therecoverable ranges of a VM or recovering a VM from a most recentcontinuous point-in-time version or recovering a VM from a specificcontinuous point-in-time version. To support these operations, examplealgorithms manage the log chain to determine if a log chain is valid forrecovery. One algorithm may include determining a shortest log chain,with a valid base snapshot. A second algorithm may include determining alongest log chain, with a valid base snapshot. These algorithms can beused to calculate recoverable ranges of a VM.

Some examples pin a log chain for recovery or to get recoverable rangesof a VM. An example continuous log chain 1400 is depicted in FIG. 14. Inthis example, the latest log chain for recovery is {S2, L3, L4}. Therecoverable range is {[S1, L4]}. An example broken log chain 1500 isshown in FIG. 15. In this example, the latest log chain for recovery is{S2, L3, L4}. The recoverable range is {[S1, L1], [S2, L4]}. Thealgorithms can be enhanced to support recovering a VM from a specificcontinuous point-in-time version.

For purposes of explanation, a stream source may be considered toinclude an abstraction of any data sources that can produce continuousstream data, for example a virtual disk of a VM is a stream source. Astream log may be considered to include an abstraction of any continuousstream data produced by a stream source. In some examples, stream logsare managed in a form of dependency chain, for example as discussedabove). A log may be pinned by 3 different references. A SelfRefreference indicates a log is alive and not expired. A LogRef referenceindicates a log is a base of other logs. A JobRef reference indicates alog is being used for recovery (e.g. Live Mount). Building a log chainto enable continuous point-in-time recovery may only be a partial flowin a replication operation, in some examples. Stream logs are like a“stream”: the source I/O data continuously “flows” into a cluster. Thedisk space consumed by stream logs may be significant for some streamsources (for example, virtual disks). In some examples, it is equallyimportant for efficient CDP to ensure that all expired stream logs arerecycled to free up the disk space as soon as possible. Log garbagecollection (GC) is a process that aims to free up occupied disk space byremoving unneeded logs and may be an integral part of a CDP product, insome examples. In a typical garbage collection cycle, any logs that arestill referenced will be kept, even if they have expired. The spaceoccupied by logs with no references will be freed and reclaimed toaccommodate new logs.

With reference to FIG. 16, example operations in a GC process 1600 arenow described. Assume all logs below should be expired based on assignedSLA policy. The following steps describe how an example log GC processworks. First, the logs are expired based on SLA policy. Typically, whena new snapshot is taken, old logs should be expired or consolidated. Butbased on various business requirements, users may want to keep some logsfor a longer period. A per stream source job will be scheduledperiodically to expire the logs based on SLA policy. The expire job willtake care of two things: first, removing self-references if a particularlog should be expired according to SLA. Second, if the expired log has abase snapshot, which means it is recoverable without relying on the baselog, then remove the reference from base log (if it exists). Withreference to FIG. 17, the first operation above will mark a log 1700 asexpired, so that it will not be used as a base log for any new logs. Thesecond operation ensures that if a newer log is recoverable from a basesnapshot, then it is safe to mark older logs as eligible for GC. Afterthe expiry operation is complete, the log chain may appear like the log1800 chain in FIG. 18, for example. The circled L1 and L4 are eligiblefor GC because there's no reference pinned on them.

Some example embodiments include GC logs. A GC operation cleans out thelogs if the references are empty. An empty reference implies that thelog has expired, no other logs depend on it, and no live jobs are usingit. So, it may be inferred that it is perform GC on these logs. Withreference to FIG. 19, a per node operation 1900 will be scheduledperiodically to perform GC on the logs. In some examples, the GCoperation addresses, firstly, removal of the log reference from the baselog and the base snapshot if these exist. Secondly, removing logmetadata where stored in a database and, thirdly, removing the log filefrom disk. After the GC operation is complete, the log chain may appearlike the example log chain 2000 in FIG. 20. Now L3 has no reference onit, so it will be recycled in the next execution of a GC operation.

Some examples include an enhanced algorithm to promote an efficiency ofthe GC operation. In the above examples, once L4 has been GC'd and theLogRef has been removed from its base log, L3 becomes eligible for GCimmediately. Aggressive GC tries to garbage collect as many logs aspossible during one job execution, for example as shown at 2100 in FIG.21. So, with aggressive GC, after one GC job execution, the log chainmay appear like the example log chain 2200 in FIG. 22. All expired logswill be garbage collected during the first execution of the GC operationassuming the logs are not being pinned for recovery during GC

In some examples, CDP enables near-continuous data protection of VMwareVMs using a VAIO framework from VMware. A VAIO filter is implemented toreplicate each I/O to a cluster. In some examples, these I/Os arewritten into a new file format called TimestampedJournal (TSJ) whichsupports point-in-time recovery for VMs. A log management componentmanages I/O stream logs, including log lifecycle management, log chainmanagement, and so forth.

In some cases, a log chain may become very long. For example, if asnapshot frequency is much longer than log retention, instances mayarise where many logs expire, but the expired logs cannot be GC'dbecause of dependent logs. If the protected VM is extremely I/Ointensive and the change rate is fairly high, logs may be rolled overfrequently, and excessive logs may be generated. In any case, applyingtoo many logs during mount or recovery may take more time and may notmeet a user's expectation of RTO.

In space saving applications, TSJs mat take more space than patch filesas they are not optimized for overwrites. Maintaining a long chain oflogs may also occupy more space. Some examples thus consolidate, andgarbage collect (GC) logs out of the applicable retention window as soonas possible to improve recovery times and save space as well. Even forlogs within the retention window, some examples still consolidate theseeven though space saving options are impacted because the TSJs areretained to support a granularity of point-in-time recoveries.

A CDP-enabled VM may include two ingestion paths: continuous stream logsand discrete snapshots. Some examples ingest all the requisite data fromstream logs and may avoid taking snapshots. In some examples, once a VMis enabled for protection by CDP, unnecessary (if any) snapshots aretaken and instead some examples automatically constructing snapshots byconverting TSJs to patch files. The use of patch files or takingsnapshots by an external source may reduce work, allow computation tohappen in a datacenter, but may increase network bandwidth yet ensureapplication consistency. Constructing snapshots in a backup site mayinvolve extra non-trivial work, allow computation to happen in acluster, may decrease consumption of network bandwidth, yet there may belittle or no application consistency. While dual ingestion may notpresent a big issue for backup because it is usually done within a datacenter, this can present an issue for replication. Replication trafficcommunicated over the internet (or VPN pipes) may have bandwidthlimitations. Avoiding dual transfer may thus be very convenient forusers. Thus, some examples make a distinction between content (the databeing stored, like a complete snapshot) and representation (how thecontent is stored in the chain, likely spread among multiple patches).

With reference to FIG. 23, a log chain 2300 is based on two streamsources (i.e. virtual disks) of one VM. If a log chain is dependent on abase snapshot it may become very long, the number of logs to be replayedduring recovery will be increasing over time and a log replayer willtake more and more time to replay all the TSJs. To address thesechallenges, two options may be possible. IN a first option, asignificant issue may be the need to replay many TSJs. To address thisissue, some examples periodically scan the log chain 2300. If it becomesexcessively long (based on a threshold for example), the examplesconsolidate the logs by converting TSJs to patch files. Multiple patchfiles are generated for a long log chain. A log store may keep track ofboth original TSJs and the converted patch files. Some examples only usethe most recent unconverted TSJs along with the converted patch filesduring mount or recovery.

A second option includes periodically scan the log chain 2300 andconverting TSJs to patch files on demand. However, instead of trackingthe converted patch files, some examples construct a new snapshot fromthe converted patch files. This snapshot is added as a new base on thelog chains, for example as shown in log chain 2400 in FIG. 24. SnapshotS2 is created as an incremental patch depending on S1. In some examples,the next ingested snapshot (S3) is created based on S2. If that is notpossible, both S2 and S3 will be based on S1. The chain 2400 will getdiverged and become a differential tree.

Some examples perform log consolidation using a ConsolidateStreamLogsoperation which is run per VM and in some examples it includes two subtasks. A first task includes a preparation operation. This operationdetermines tail logs for each stream source. A tail log is one in whichno other logs depend on it. The log chains (one chain for each streamsource) are traversed backward until a common base snapshot is found. Atotal size is calculated for all log chains from the tail log to thecommon base snapshot (these are the sub chains that will be used forrecovery). If the total size reaches a predefined threshold, the visitedlogs to be consolidated are saved. The total size is reset, and thepreparation operation is repeated from new base snapshot. Thepreparation process is terminated if it reaches the head of any logchains.

The first task may also include a stream consolidation operation. Thisoperation, for each stream source, creates an incremental patch based onthe current base snapshot, and calls a log converter API to convert thestream logs collected by the preparation operation to the new patchfile. For the VM, a new snapshot is created from the patch filesgenerated from above operations. The constructed snapshot is added as anew base snapshot on the log chains for the given VM.

In a second task for avoiding dual ingestion, an existing snapshotingestion path is disabled, and some examples rely solely on a CDP logstream ingestion path. In some examples, the consolidation operation isenhanced to take the snapshot SLA into account as well. A consolidationoperation is scheduled more frequently than or at least equal to anSLA-defined snapshot frequency. Log chains are consolidated andconverted to snapshots before the log chain becomes too long. In thiscase, at lower frequencies, an SLA obligation can be met accordingly. Ifan SLA snapshot frequency is higher, log consolidation may occur beforethe SLA obligation is due, for example as shown in the example log chain2500 in FIG. 25. In this case, SLA is defined to take a snapshot every 4hours. However, because there are excessive logs (based on a thresholdfor example), the consolidation operation has constructed a new snapshotS2 at time 2:30. In this event, one option is to skip the snapshotoperation scheduled at 4:00 and defer (or reschedule) it to 6:30. Anappropriate API may be provided to support conversion of TSJs to a patchfile.

Thus, some examples of the present disclosure include methodembodiments. With reference to FIG. 26, an example method 2600 forcontinuous data protection for a virtual machine (VM) having a virtualdisk comprises at least the following operations: at 2602, obtaining abase snapshot of the virtual disk; at 2604, intercepting, at aninterception point in an I/O path, a virtual disk I/O stream between theVM and a virtualization server; at 2606, replicating the I/O stream at abackup site; at 2608, storing the replicated I/O stream at the backupsite in I/O logs; at 2610, forming a recoverable snapshot-log chain byapplying the replicated I/O stream stored in the I/O logs on top of thebase snapshot; at 2612, receiving a request for recoverable data from areplication target; and at 2614, sending data to the replication targetbased at least on a portion of the recoverable snapshot-log chain.

The operations in method 2600 may further comprise establishing a filterframework at the interception point, the filter framework including anI/O stack and an I/O filter. The virtualization server may be an ESXhypervisor server and the operations may further comprise including afilter driver for the filter framework within the ESX hypervisor server.The operations may further comprise configuring the filter framework toenable an I/O touch point in the I/O stream. The I/O stream may includean I/O cancellation and the operations further comprise configuring thefilter driver to intercept only completed I/Os in the I/O stream usingthe enabled I/O touch point. The I/O cancellation may be a distributedI/O cancellation and the operations may further comprise managing thedistributed I/O cancellation at the I/O stack and not at the I/O filterof the filter framework.

With reference to FIG. 27, an example method 2700 is provided foroptimizing a recovery point objective (RPO) in a virtual machine (VM)having a virtual disk. The method 2700 may comprise at least thefollowing operations: at 2702, tapping off I/O data at a virtualizationserver by a filter framework; at 2704, collecting the I/O data at afilter stack, and providing a filter touchpoint selection at the filterframework to parse the tapped off I/O data and configure its collection;at 2706, sending a parsed section of the collected I/O data to a logreceiver for storage as a log-chain in an I/O log; at 2708, receiving arequest for recoverable data from a replication target; and at 2710,causing or facilitating a transmission of requested data to thereplication target based at least on a portion of the stored log-chain.

The parsed section of the I/O data may include only completed I/Orequests exchanged between the VM and the virtualization server. Theparsed section of the I/O data may exclude cancelled I/O requestsexchanged between the VM and the virtualization server. The operationsof method 2700 may further comprise forming a recoverable snapshot-logchain by applying the log-chain to a base snapshot of the virtual disk.The operations may further comprise establishing a network cache for theparsed section of the collected I/O data between the filter frameworkand the log receiver. The operations may further comprise establishing acache for the parsed section of the collected I/O data at the logreceiver.

With reference to FIG. 28, an example method 2800 is provided forcontinuous data protection for a virtual machine (VM) having a virtualdisk. The method 2800 may comprise at least the following operations: at2802, obtaining a base snapshot of the virtual disk, at 2804,intercepting, at an interception point in an I/O path, a virtual diskI/O stream between the VM and a virtualization server; at 2806,replicating the I/O stream at a log receiver, and storing the replicatedI/O stream at the log receiver in I/O logs; at 2808, forming arecoverable snapshot-log chain by applying the replicated I/O streamstored in the I/O logs on top of the base snapshot; at 2810, receiving,via a graphical user interface, a user request for recoverable data at areplication target, the request based on a recovery protocol including arecovery point objective (RPO) of less than 60 seconds; and at 2812,meeting or exceeding the RPO by sending data less than 60 seconds old tothe replication target based at least on a portion of the recoverablesnapshot-log chain.

The operations may further comprise establishing a filter framework atthe interception point, the filter framework including an I/O stack andan I/O filter. The virtualization server may be an ESX hypervisor serverand the operations may further comprise including a filter driver forthe filter framework within the ESX hypervisor server. The operationsmay further comprise configuring the filter framework to enable an I/Otouch point in the I/O stream. The I/O stream may include an I/Ocancellation and the operations may further comprise configuring thefilter driver to intercept only completed I/Os in the I/O stream usingthe enabled I/O touch point. The I/O cancellation may be a distributedI/O cancellation and the operations may further comprise managing thedistributed I/O cancellation at the I/O stack and not at the I/O filterof the filter framework.

With reference to FIG. 29, an example method 2900 is provided forcontinuous data protection for a virtual machine (VM) having a virtualdisk. The method 2900 may comprise at least the following operations: at2902, capturing a base snapshot of the virtual disk; at 2904, receiving,at a backup site, I/O data from an intercepted I/O stream between the VMand a virtualization server; at 2906, buffering the received I/O datainto memory and flushing the I/O data to a log file; at 2908, includinga log file with the base snapshot in an I/O log to form a recoverablesnapshot-log chain; at 2910, determining a request for recoverable datafrom a replication target; and at 2912, pushing the requested data tothe replication target based at least on a portion of the recoverablesnapshot-log chain.

The operations may further comprise establishing an instance of a logreplication sender at the backup site to communicate with a logreplication receiver at the replication target. The operations mayfurther comprise configuring the log replication receiver at thereplication target to run at an unmodified existing snapshot recoveryservice. The operations may further comprise configuring a CDP metadataservice to communicate with the log replication sender and the logreplication receiver. The operations may further comprise configuringthe log replication sender to identify a log file to be replicated and,based on the identified log file including a closed file, including thecontents of the log file in a closed replication. The operations mayfurther comprise configuring the log replication sender to identify alog file to be replicated and, based on the identified log fileincluding an open file receiving I/O data from the intercepted I/Ostream, including the I/O data in a live replication.

With reference to FIG. 30, an example method 3000 is provided foroptimizing a recovery point objective (RPO) for a virtual machine (VM)having a virtual disk. The method may comprise at least the followingoperations: at 3002, storing a base snapshot of the virtual disk; at3004, receiving, at a log receiver, I/O data from an intercepted I/Ostream between the VM and a virtualization server; at 3006, storing, atthe log receiver, the I/O data as a plurality of log chains in one ormore log files; at 3008, associating a log chain in the plurality of logchains with the base snapshot to form a recoverable snapshot-log chain;at 3010, receiving a request for recoverable data from a replicationtarget; and at 3012, transmitting the requested data to the replicationtarget including at least on a portion of the recoverable snapshot-logchain.

The operations may further comprise establishing an instance of a logreplication sender at the log receiver to communicate with a logreplication receiver at the replication target. The operations mayfurther comprise configuring the log replication receiver at thereplication target to run at an unmodified existing snapshot recoveryservice. The operations may further comprise configuring a CDP metadataservice to communicate with the log replication sender and the logreplication receiver. The operations may further comprise configuringthe log replication sender to identify a log file to be replicated and,based on the identified log file including a closed file, including thecontents of the log file in a closed replication. The operations mayfurther comprise configuring the log replication sender to identify alog file to be replicated and, based on the identified log fileincluding an open file receiving I/O data, including the I/O data in alive replication.

With reference to FIG. 31, an example method 3100 is provided foroptimizing a recovery point objective (RPO) for a virtual machine (VM)having a virtual disk. The method 3100 may comprise at least thefollowing operations: at 3102, storing a base snapshot of the virtualdisk; at 3104, receiving, at a log receiver, I/O data from anintercepted I/O stream source between the VM and a virtualizationserver; at 3106, storing the I/O data at the log receiver in one or morelog files, the I/O data including a plurality of log chains; at 3108,associating a log chain in the plurality of log chains with the basesnapshot to form a recoverable snapshot-log chain; at 3110, receiving arequest for recoverable data from a replication target; and at 3112,transmitting the requested data including at least on a portion of therecoverable snapshot-log chain to a disk seeking replication at thereplication target.

The operations may further comprise establishing a continuous dataprotection (CDP) metadata service in communication with the log receiverto scan disks seeking replication periodically to determine and assign areplication owner node for the disk seeking replication at thereplication target. The operations further comprise assigning a workerpool to process each disk seeking replication from the replication ownernode. The operations may further comprise configuring the CDP metadataservice to communicate with a log replication sender at the logreceiver, and a log replication receiver at the replication target. Theoperations may further comprise configuring a CDP replicationorchestrator to identify the I/O stream source from a plurality of I/Ostream sources and identify replication metadata including an owner nodeidentification and a claim time. The operations may further compriseconfiguring the CDP replication orchestrator to identify a next logchain to replicate in a snapshot-log chain replication.

With reference to FIG. 35, an example method 3500 is provided forcontinuous data protection for a virtual machine (VM) having a virtualdisk, the method comprising at least the following operations: at 3502,determining an existence or availability of a base snapshot of thevirtual disk; at 3504, intercepting, at an interception point in an I/Opath, a virtual disk I/O stream between the VM and a virtualizationserver; at 3506, replicating the I/O stream at a backup site; at 3508,storing the replicated I/O stream at the backup site in I/O logs; at3510, based on the existence or availability of the base snapshot,forming a recoverable snapshot-log chain by applying the replicated I/Ostream stored in the I/O logs on top of the base snapshot; at 3512,receiving a request for recoverable data from a replication target; andat 3514, sending data to the replication target based at least on aportion of the recoverable snapshot-log chain.

With reference to FIG. 36, an example method 3600 is provided forestablishing a system for continuous data protection, the methodincluding operations comprising, at least: at 3602, instantiating oridentifying a driver to capture continuous I/Os exchanged between aserver and a virtual machine (VM) having a virtual disk, cache the I/Os,and send I/O data as stream logs to one or more clusters; at 3604,instantiating or identifying a log receiver service (LRS), the LRSrunning on nodes to receive the stream logs and write the stream logs toa disk, wherein the steam logs are captured after a base snapshot in aseries of snapshots of the virtual disk is taken, the base snapshot toserve as a base of subsequent logs, the stream logs capturedsequentially one after another, a later stream log depending on a formerone in a continuous log chain; and wherein, at 3606, a validity of a logstream in the continuous log chain is affirmed on the basis of anexistence of a base snapshot in the series of snapshots, the VMrecoverable from a specific continuous point-in-time versioncorresponding to a log in the log stream.

With reference to FIG. 37, an example method 3700 is provided forcontinuous data protection for a virtual machine (VM) having a virtualdisk, the method comprising at least the following operations: at 3702,obtaining or identifying recoverable ranges of a VM; and at 3704,recovering the VM from a most recent continuous point-in-time version ofthe virtual disk or a specific continuous point-in-time version of thevirtual disk by implementing a set of algorithms, the set of algorithmsto determine if a log chain in a series of log chains stored at arecovery site is valid for recovery of the VM, wherein a first algorithmof the set of algorithms includes determining a shortest log chainhaving a valid base snapshot, and a second algorithm in the set ofalgorithms includes determining a longest log chain having a valid basesnapshot.

With reference to FIG. 38, an example method 3800 is provided forcontinuous data protection for a virtual machine (VM) having a virtualdisk, the method comprising at least the following operations: at 3802,intercepting, at an interception point in an I/O path, a virtual diskI/O stream between the VM and a virtualization server; at 3804, storingthe I/O stream at a backup site; at 3806, forming a recoverablesnapshot-log chain by associating the stored I/O stream with a basesnapshot; at 3808, receiving a request for recoverable data from areplication target; and, at 3810, sending data to the replication targetbased at least on a portion of the recoverable snapshot-log chain.

Some example embodiments include systems as summarized further above, orspecifically described herein, that include processors configured toperform one or more of the method operations summarized above ordescribed herein. Some example embodiments also include non-transitorymachine-readable media that include instructions for performing one ormore of the method operations summarized above or described herein.

FIG. 32 is a block diagram illustrating an example of a softwarearchitecture that may be installed on a machine, according to someexample embodiments. FIG. 32 is merely a non-limiting example of asoftware architecture, and it will be appreciated that many otherarchitectures may be implemented to facilitate the functionalitydescribed herein. The software architecture 3202 may be executing onhardware such as a machine 3400 of FIG. 34 that includes, among otherthings, processors 3410, memory 3430, and I/O components 3450. Arepresentative hardware layer 3204 is illustrated and can represent, forexample, the machine 3400 of FIG. 34. The representative hardware layer3204 comprises one or more processing units 3206 having associatedexecutable instructions 3208. The executable instructions 3208 representthe executable instructions of the software architecture 3202, includingimplementation of the methods, modules, and so forth described herein.The hardware layer 3204 also includes memory or storage modules 3210,which also have the executable instructions 3208. The hardware layer3204 may also comprise other hardware 3212, which represents any otherhardware of the hardware layer 3204, such as the other hardwareillustrated as part of the machine 3200.

In the example architecture of FIG. 32, the software architecture 3202may be conceptualized as a stack of layers, where each layer providesparticular functionality. For example, the software architecture 3202may include layers such as an operating system 3214, libraries 3216,frameworks/middleware 3218, applications 3220, and a presentation layer3244. Operationally, the applications 3220 or other components withinthe layers may invoke API calls 3224 through the software stack andreceive a response, returned values, and so forth (illustrated asmessages 3226) in response to the API calls 3224. The layers illustratedare representative in nature, and not all software architectures haveall layers. For example, some mobile or special purpose operatingsystems may not provide a frameworks/middleware 3218 layer, while othersmay provide such a layer. Other software architectures may includeadditional or different layers.

The operating system 3214 may manage hardware resources and providecommon services. The operating system 3214 may include, for example, akernel 3228, services 3230, and drivers 3232. The kernel 3228 may act asan abstraction layer between the hardware and the other software layers.For example, the kernel 3228 may be responsible for memory management,processor management (e.g., scheduling), component management,networking, security settings, and so on. The services 3230 may provideother common services for the other software layers. The drivers 3232may be responsible for controlling or interfacing with the underlyinghardware. For instance, the drivers 3232 may include display drivers,camera drivers, Bluetooth® drivers, flash memory drivers, serialcommunication drivers (e.g., Universal Serial Bus (USB) drivers), Wi-Fi®drivers, audio drivers, power management drivers, and so forth dependingon the hardware configuration.

The libraries 3216 may provide a common infrastructure that may beutilized by the applications 3220 and/or other components and/or layers.The libraries 3216 typically provide functionality that allows othersoftware modules to perform tasks in an easier fashion than byinterfacing directly with the underlying operating system 3214functionality (e.g., kernel 3228, services 3230, or drivers 3232). Thelibraries 3216 may include system libraries 3234 (e.g., C standardlibrary) that may provide functions such as memory allocation functions,string manipulation functions, mathematic functions, and the like. Inaddition, the libraries 3216 may include API libraries 3236 such asmedia libraries (e.g., libraries to support presentation andmanipulation of various media formats such as MPEG4, H.264, MP3, AAC,AMR, JPG, PNG), graphics libraries (e.g., an OpenGL framework that maybe used to render 2D and 3D graphic content on a display), databaselibraries (e.g., SQLite that may provide various relational databasefunctions), web libraries (e.g., WebKit that may provide web browsingfunctionality), and the like. The libraries 3216 may also include a widevariety of other libraries 3238 to provide many other APIs to theapplications 3220 and other software components/modules.

The frameworks 3218 (also sometimes referred to as middleware) mayprovide a higher-level common infrastructure that may be utilized by theapplications 3220 or other software components/modules. For example, theframeworks 3218 may provide various graphic user interface (GUI)functions, high-level resource management, high-level location services,and so forth. The frameworks 3218 may provide a broad spectrum of otherAPIs that may be utilized by the applications 3220 and/or other softwarecomponents/modules, some of which may be specific to a particularoperating system or platform.

The applications 3220 include built-in applications 3240 and/orthird-party applications 3242. Examples of representative built-inapplications 3240 may include, but are not limited to, a homeapplication, a contacts application, a browser application, a bookreader application, a location application, a media application, amessaging application, or a game application.

The third-party applications 3242 may include any of the built-inapplications 3240, as well as a broad assortment of other applications.In a specific example, the third-party applications 3242 (e.g., anapplication developed using the Android™ or iOS™ software developmentkit (SDK) by an entity other than the vendor of the particular platform)may be mobile software running on a mobile operating system such asiOS™, Android™, Windows® Phone, or other mobile operating systems. Inthis example, the third-party applications 3242 may invoke the API calls3224 provided by the mobile operating system such as the operatingsystem 3214 to facilitate functionality described herein.

The applications 3220 may utilize built-in operating system functions(e.g., kernel 3228, services 3230, or drivers 3232), libraries (e.g.,system 3234, APIs 3236, and other libraries 3238), orframeworks/middleware 3218 to create user interfaces to interact withusers of the system. Alternatively, or additionally, in some systems,interactions with a user may occur through a presentation layer, such asthe presentation layer 3244. In these systems, the application/module“logic” can be separated from the aspects of the application/module thatinteract with the user.

Some software architectures utilize virtual machines. In the example ofFIG. 32, this is illustrated by a virtual machine 3248. A virtualmachine creates a software environment where applications/modules canexecute as if they were executing on a hardware machine e.g., themachine 3400 of FIG. 34, for example). A virtual machine 3248 is hostedby a host operating system (e.g., operating system 3214) and typically,although not always, has a virtual machine monitor 3246, which managesthe operation of the virtual machine 3248 as well as the interface withthe host operating system (e.g., operating system 3214). A softwarearchitecture executes within the virtual machine 3248, such as anoperating system 3250, libraries 3252, frameworks/middleware 3254,applications 3256, or a presentation layer 3258. These layers ofsoftware architecture executing within the virtual machine 3248 can bethe same as corresponding layers previously described or may bedifferent.

FIG. 33 is a block diagram 3300 illustrating an architecture of software3302, which can be installed on any one or more of the devices describedabove. FIG. 33 is merely a non-limiting example of a softwarearchitecture, and it will be appreciated that many other architecturescan be implemented to facilitate the functionality described herein. Invarious embodiments, the software 3302 is implemented by hardware suchas a machine 3400 of FIG. 34 that includes processors 3410, memory 3430,and I/O components 3450. In this example architecture, the software 3302can be conceptualized as a stack of layers where each layer may providea particular functionality. For example, the software 3302 includeslayers such as an operating system 3304, libraries 3306, frameworks3308, and applications 3310. Operationally, the applications 3310 invokeapplication programming interface (API) calls 3312 through the softwarestack and receive messages 3314 in response to the API calls 3312,consistent with some embodiments.

In various implementations, the operating system 3304 manages hardwareresources and provides common services. The operating system 3304includes, for example, a kernel 3320, services 3322, and drivers 3324.The kernel 3320 acts as an abstraction layer between the hardware andthe other software layers, consistent with some embodiments. Forexample, the kernel 3320 provides memory management, processormanagement (e.g., scheduling), component management, networking, andsecurity settings, among other functionality. The services 3322 canprovide other common services for the other software layers. The drivers3324 are responsible for controlling or interfacing with the underlyinghardware, according to some embodiments. For instance, the drivers 3324can include display drivers, camera drivers, BLUETOOTH® or BLUETOOTH®Low Energy drivers, flash memory drivers, serial communication drivers(e.g., Universal Serial Bus (USB) drivers), WI-FI® drivers, audiodrivers, power management drivers, and so forth.

In some embodiments, the libraries 3306 provide a low-level commoninfrastructure utilized by the applications 3310. The libraries 3306 caninclude system libraries 3330 (e.g., C standard library) that canprovide functions such as memory allocation functions, stringmanipulation functions, mathematic functions, and the like. In addition,the libraries 3306 can include API libraries 3332 such as medialibraries (e.g., libraries to support presentation and manipulation ofvarious media formats such as Moving Picture Experts Group-4 (MPEG4),Advanced Video Coding (H.264 or AVC), Moving Picture Experts GroupLayer-3 (MP3), Advanced Audio Coding (AAC), Adaptive Multi-Rate (AMR)audio codec, Joint Photographic Experts Group (JPEG or JPG), or PortableNetwork Graphics (PNG)), graphics libraries (e.g., an OpenGL frameworkused to render in two dimensions (2D) and three dimensions (3D) in agraphic content on a display), database libraries (e.g., SQLite toprovide various relational database functions), web libraries (e.g.,WebKit to provide web browsing functionality), and the like. Thelibraries 3306 can also include a wide variety of other libraries 3334to provide many other APIs to the applications 3310.

The frameworks 3308 provide a high-level common infrastructure that canbe utilized by the applications 3310, according to some embodiments. Forexample, the frameworks 3308 provide various graphic user interface(GUI) functions, high-level resource management, high-level locationservices, and so forth. The frameworks 3308 can provide a broad spectrumof other APIs that can be utilized by the applications 3310, some ofwhich may be specific to a particular operating system or platform.

In an example embodiment, the applications 3310 include a homeapplication 3350, a contacts application 3352, a browser application3354, a book reader application 3356, a location application 3358, amedia application 3360, a messaging application 3362, a game application3364, and a broad assortment of other applications such as a third-partyapplication 3366. According to some embodiments, the applications 3310are programs that execute functions defined in the programs. Variousprogramming languages can be employed to create one or more of theapplications 3310, structured in a variety of manners, such asobject-oriented programming languages (e.g., Objective-C, Java, or C++)or procedural programming languages (e.g., C or assembly language). In aspecific example, the third-party application 3366 (e.g., an applicationdeveloped using the ANDROID™ or IOS™ software development kit (SDK) byan entity other than the vendor of the particular platform) may bemobile software running on a mobile operating system such as IOS™,ANDROID™, WINDOWS® Phone, or another mobile operating system. In thisexample, the third-party application 3366 can invoke the API calls 3312provided by the operating system 3304 to facilitate functionalitydescribed herein.

FIG. 34 illustrates a diagrammatic representation of a machine 3400 inthe form of a computer system within which a set of instructions may beexecuted for causing the machine to perform any one or more of themethodologies discussed herein, according to an example embodiment.Specifically, FIG. 34 shows a diagrammatic representation of the machine3400 in the example form of a computer system, within which instructions3416 (e.g., software, a program, an application, an applet, an app, orother executable code) for causing the machine 3400 to perform any oneor more of the methodologies discussed herein may be executed.Additionally, or alternatively, the instructions 3416 may implement theoperations of the methods shown in FIGS. 13-18, or as elsewheredescribed herein. The instructions 3416 transform the general,non-programmed machine 3400 into a particular machine 3400 programmed tocarry out the described and illustrated functions in the mannerdescribed. In alternative embodiments, the machine 3400 operates as astandalone device or may be coupled (e.g., networked) to other machines.In a networked deployment, the machine 3400 may operate in the capacityof a server machine or a client machine in a server-client networkenvironment, or as a peer machine in a peer-to-peer (or distributed)network environment. The machine 3400 may comprise, but not be limitedto, a server computer, a client computer, a personal computer (PC), atablet computer, a laptop computer, a netbook, a set-top box (STB), aPDA, an entertainment media system, a cellular telephone, a smart phone,a mobile device, a wearable device (e.g., a smart watch), a smart homedevice (e.g., a smart appliance), other smart devices, a web appliance,a network router, a network switch, a network bridge, or any machinecapable of executing the instructions 3416, sequentially or otherwise,that specify actions to be taken by the machine 3400. Further, whileonly a single machine 3400 is illustrated, the term “machine” shall alsobe taken to include a collection of machines 3400 that individually orjointly execute the instructions 3416 to perform any one or more of themethodologies discussed herein.

The machine 3400 may include processors 3410, memory 3430, and I/Ocomponents 3450, which may be configured to communicate with each othersuch as via a bus 3402. In an example embodiment, the processors 3410(e.g., a Central Processing Unit (CPU), a Reduced Instruction SetComputing (RISC) processor, a Complex Instruction Set Computing (CISC)processor, a Graphics Processing Unit (GPU), a Digital Signal Processor(DSP), an ASIC, a Radio-Frequency Integrated Circuit (RFIC), anotherprocessor, or any suitable combination thereof) may include, forexample, a processor 3412 and a processor 3414 that may execute theinstructions 3416. The term “processor” is intended to includemulti-core processors that may comprise two or more independentprocessors (sometimes referred to as “cores”) that may executeinstructions contemporaneously. Although FIG. 34 shows multipleprocessors 3410, the machine 3400 may include a single processor with asingle core, a single processor with multiple cores (e.g., a multi-coreprocessor), multiple processors with a single core, multiple processorswith multiples cores, or any combination thereof.

The memory 3430 may include a main memory 3432, a static memory 3434,and a storage unit 3436, both accessible to the processors 3410 such asvia the bus 3402. The main memory 3430, the static memory 3434, andstorage unit 3436 store the instructions 3416 embodying any one or moreof the methodologies or functions described herein. The instructions3416 may also reside, completely or partially, within the main memory3432, within the static memory 3434, within the storage unit 3436,within at least one of the processors 3410 (e.g., within the processor'scache memory), or any suitable combination thereof, during executionthereof by the machine 3400.

The I/O components 3450 may include a wide variety of components toreceive input, provide output, produce output, transmit information,exchange information, capture measurements, and so on. The specific I/Ocomponents 3450 that are included in a particular machine will depend onthe type of machine. For example, portable machines such as mobilephones will likely include a touch input device or other such inputmechanisms, while a headless server machine will likely not include sucha touch input device. It will be appreciated that the I/O components3450 may include many other components that are not shown in FIG. 34.The I/O components 3450 are grouped according to functionality merelyfor simplifying the following discussion and the grouping is in no waylimiting. In various example embodiments, the I/O components 3450 mayinclude output components 3452 and input components 3454. The outputcomponents 3452 may include visual components (e.g., a display such as aplasma display panel (PDP), a light emitting diode (LED) display, aliquid crystal display (LCD), a projector, or a cathode ray tube (CRT)),acoustic components (e.g., speakers), haptic components (e.g., avibratory motor, resistance mechanisms), other signal generators, and soforth. The input components 3454 may include alphanumeric inputcomponents (e.g., a keyboard, a touch screen configured to receivealphanumeric input, a photo-optical keyboard, or other alphanumericinput components), point-based input components (e.g., a mouse, atouchpad, a trackball, a joystick, a motion sensor, or another pointinginstrument), tactile input components (e.g., a physical button, a touchscreen that provides location and/or force of touches or touch gestures,or other tactile input components), audio input components (e.g., amicrophone), and the like.

In further example embodiments, the I/O components 3450 may includebiometric components 3456, motion components 3458, environmentalcomponents 3460, or position components 3462, among a wide array ofother components. For example, the biometric components 3456 may includecomponents to detect expressions (e.g., hand expressions, facialexpressions, vocal expressions, body gestures, or eye tracking), measurebiosignals (e.g., blood pressure, heart rate, body temperature,perspiration, or brain waves), identify a person (e.g., voiceidentification, retinal identification, facial identification,fingerprint identification, or electroencephalogram-basedidentification), and the like. The motion components 3458 may includeacceleration sensor components (e.g., accelerometer), gravitation sensorcomponents, rotation sensor components (e.g., gyroscope), and so forth.The environmental components 3460 may include, for example, illuminationsensor components (e.g., photometer), temperature sensor components(e.g., one or more thermometers that detect ambient temperature),humidity sensor components, pressure sensor components (e.g.,barometer), acoustic sensor components (e.g., one or more microphonesthat detect background noise), proximity sensor components (e.g.,infrared sensors that detect nearby objects), gas sensors (e.g., gasdetection sensors to detection concentrations of hazardous gases forsafety or to measure pollutants in the atmosphere), or other componentsthat may provide indications, measurements, or signals corresponding toa surrounding physical environment. The position components 3462 mayinclude location sensor components (e.g., a GPS receiver component),altitude sensor components (e.g., altimeters or barometers that detectair pressure from which altitude may be derived), orientation sensorcomponents (e.g., magnetometers), and the like.

Communication may be implemented using a wide variety of technologies.The I/O components 3450 may include communication components 3464operable to couple the machine 3400 to a network 3480 or devices 3470via a coupling 3482 and a coupling 3472, respectively. For example, thecommunication components 3464 may include a network interface componentor another suitable device to interface with the network 3480. Infurther examples, the communication components 3464 may include wiredcommunication components, wireless communication components, cellularcommunication components, Near Field Communication (NFC) components,Bluetooth® components (e.g., Bluetooth® Low Energy), Wi-Fi® components,and other communication components to provide communication via othermodalities. The devices 3470 may be another machine or any of a widevariety of peripheral devices (e.g., a peripheral device coupled via aUSB).

Moreover, the communication components 3464 may detect identifiers orinclude components operable to detect identifiers. For example, thecommunication components 3464 may include Radio Frequency Identification(RFID) tag reader components, NFC smart tag detection components,optical reader components (e.g., an optical sensor to detectone-dimensional bar codes such as Universal Product Code (UPC) bar code,multi-dimensional bar codes such as Quick Response (QR) code, Azteccode, Data Matrix, Dataglyph, MaxiCode, PDF417, Ultra Code, UCC RSS-2Dbar code, and other optical codes), or acoustic detection components(e.g., microphones to identify tagged audio signals). In addition, avariety of information may be derived via the communication components3464, such as location via Internet Protocol (IP) geolocation, locationvia Wi-Fi® signal triangulation, location via detecting an NFC beaconsignal that may indicate a particular location, and so forth.

The various memories (i.e., 3430, 3432, 3434, and/or memory of theprocessor(s) 3410) and/or storage unit 3436 may store one or more setsof instructions and data structures (e.g., software) embodying orutilized by any one or more of the methodologies or functions describedherein. These instructions (e.g., the instructions 3416), when executedby processor(s) 3410, cause various operations to implement thedisclosed embodiments.

As used herein, the terms “machine-storage medium,” “device-storagemedium,” “computer-storage medium” mean the same thing and may be usedinterchangeably in this disclosure. The terms refer to a single ormultiple storage devices and/or media (e.g., a centralized ordistributed database, and/or associated caches and servers) that storeexecutable instructions and/or data. The terms shall accordingly betaken to include, but not be limited to, solid-state memories, andoptical and magnetic media, including memory internal or external toprocessors. Specific examples of machine-storage media, computer-storagemedia and/or device-storage media include non-volatile memory, includingby way of example semiconductor memory devices, e.g., erasableprogrammable read-only memory (EPROM), electrically erasableprogrammable read-only memory (EEPROM), FPGA, and flash memory devices;magnetic disks such as internal hard disks and removable disks;magneto-optical disks; and CD-ROM and DVD-ROM disks. The terms“machine-storage media,” “computer-storage media,” and “device-storagemedia” specifically exclude carrier waves, modulated data signals, andother such media, at least some of which are covered under the term“signal medium” discussed below.

In various example embodiments, one or more portions of the network 3480may be an ad hoc network, an intranet, an extranet, a VPN, a LAN, aWLAN, a WAN, a WWAN, a MAN, the Internet, a portion of the Internet, aportion of the PSTN, a plain old telephone service (POTS) network, acellular telephone network, a wireless network, a Wi-Fi® network,another type of network, or a combination of two or more such networks.For example, the network 3480 or a portion of the network 3480 mayinclude a wireless or cellular network, and the coupling 3482 may be aCode Division Multiple Access (CDMA) connection, a Global System forMobile communications (GSM) connection, or another type of cellular orwireless coupling. In this example, the coupling 3482 may implement anyof a variety of types of data transfer technology, such as SingleCarrier Radio Transmission Technology (1×RTT), Evolution-Data Optimized(EVDO) technology, General Packet Radio Service (GPRS) technology,Enhanced Data rates for GSM Evolution (EDGE) technology, thirdGeneration Partnership Project (3GPP) including 3G, fourth generationwireless (4G) networks, Universal Mobile Telecommunications System(UMTS), High Speed Packet Access (HSPA), Worldwide Interoperability forMicrowave Access (WiMAX), Long Term Evolution (LTE) standard, othersdefined by various standard-setting organizations, other long rangeprotocols, or other data transfer technology.

The instructions 3416 may be transmitted or received over the network3480 using a transmission medium via a network interface device (e.g., anetwork interface component included in the communication components3464) and utilizing any one of a number of well-known transfer protocols(e.g., hypertext transfer protocol (HTTP)). Similarly, the instructions3416 may be transmitted or received using a transmission medium via thecoupling 3472 (e.g., a peer-to-peer coupling) to the devices 3470. Theterms “transmission medium” and “signal medium” mean the same thing andmay be used interchangeably in this disclosure. The terms “transmissionmedium” and “signal medium” shall be taken to include any intangiblemedium that is capable of storing, encoding, or carrying theinstructions 3416 for execution by the machine 3400, and includesdigital or analog communications signals or other intangible media tofacilitate communication of such software. Hence, the terms“transmission medium” and “signal medium” shall be taken to include anyform of modulated data signal, carrier wave, and so forth. The term“modulated data signal” means a signal that has one or more of itscharacteristics set or changed in such a matter as to encode informationin the signal.

The terms “machine-readable medium,” “computer-readable medium” and“device-readable medium” mean the same thing and may be usedinterchangeably in this disclosure. The terms are defined to includeboth machine-storage media and transmission media. Thus, the termsinclude both storage devices/media and carrier waves/modulated datasignals.

Although an embodiment has been described with reference to specificexample embodiments, it will be evident that various modifications andchanges may be made to these embodiments without departing from thebroader spirit and scope of the invention. Accordingly, thespecification and drawings are to be regarded in an illustrative ratherthan a restrictive sense. The accompanying drawings that form a parthereof, show by way of illustration, and not of limitation, specificembodiments in which the subject matter may be practiced. Theembodiments illustrated are described in sufficient detail to enablethose skilled in the art to practice the teachings disclosed herein.Other embodiments may be utilized and derived therefrom, such thatstructural and logical substitutions and changes may be made withoutdeparting from the scope of this disclosure. This Detailed Description,therefore, is not to be taken in a limiting sense, and the scope ofvarious embodiments is defined only by the appended claims, along withthe full range of equivalents to which such claims are entitled.

Such embodiments of the inventive subject matter may be referred toherein, individually and/or collectively, by the term “invention” merelyfor convenience and without intending to voluntarily limit the scope ofthis application to any single invention or inventive concept if morethan one is in fact disclosed. Thus, although specific embodiments havebeen illustrated and described herein, it should be appreciated that anyarrangement calculated to achieve the same purpose may be substitutedfor the specific embodiments shown. This disclosure is intended to coverany and all adaptations or variations of various embodiments.Combinations of the above embodiments, and other embodiments notspecifically described herein, will be apparent to those of skill in theart upon reviewing the above description.

1. A method comprising: receiving, at a backup site, I/O dataintercepted from an I/O stream between a virtual machine (VM) and avirtualization server; flushing the I/O data to a first log file, thefirst log file being included in a first plurality of log files, eachlog file in the first plurality of log files, other than a second logfile included in the first plurality of log files, including the I/Odata intercepted from the I/O stream between the VM and thevirtualization server, the second log file, of the first plurality oflog files, further including a base snapshot of the VM to form arecoverable snapshot-log chain; and pushing data to a replication targetbased on the recoverable snapshot-log chain.
 2. The method of claim 1,further comprising: establishing an instance of a log replication senderat a backup site to communicate with a log replication receiver at areplication target; and determining a request for data from thereplication target.
 3. The method of claim 2, wherein the firstplurality of log files includes a second plurality of log files, themethod of claim 1 further comprising: buffering the I/O data into memorybefore the flushing the I/O data to a log file; and removing the secondplurality of log files from the recoverable snapshot-log chain based ona first service level agreement policy, the second plurality of logfiles including the second log file.
 4. The method of claim 3, furthercomprising configuring the log replication receiver at the replicationtarget to run at an unmodified existing snapshot recovery service. 5.The method of claim 3, further comprising configuring a CDP metadataservice to communicate with the log replication sender and the logreplication receiver.
 6. The method of claim 3, further comprising:configuring the log replication sender to identify a log file to bereplicated in the first plurality of log files at the log receiver; andbased on the identified log file including a closed file, includingcontents of the log file in a closed replication.
 7. The method of claim6, wherein the configuring the log replication sender to identify a logfile to be replicated in the first plurality of log files at the logreceiver and, based on the identified log file including an open filereceiving I/O data from the intercepted I/O stream, including the I/Odata in a live replication.
 8. A system comprising: at least oneprocessor for executing machine-readable instructions; and a memorystoring instructions configured to cause the at least one processor toperform operations comprising: receiving, at a backup site, I/O dataintercepted from an I/O stream between a virtual machine (VM) and avirtualization server; flushing the I/O data to a first log file, thefirst log file being included in a first plurality of log files, eachlog file in the first plurality of log files, other than a second logfile included in the first plurality of log files, including the/O dataintercepted from the I/O stream between the VM and the virtualizationserver, the second log file, of the first plurality of log files,further including a base snapshot of the VM to form a recoverablesnapshot-log chain; and pushing data to a replication target based onthe recoverable snapshot-log chain.
 9. The system of claim 8, whereinthe operations further comprise: establishing an instance of a logreplication sender at a backup site to communicate with a logreplication receiver at the replication target; and determining arequest for data from a replication target.
 10. The system of claim 9,wherein the first plurality of log files includes a second plurality oflog files, the system of claim 1 wherein the operations furthercomprise: buffering the I/O data into memory before the flushing the I/Odata to a log file; and removing the second plurality of log files fromthe recoverable snapshot-log chain based on a first service levelagreement policy, the second plurality of log files including the secondlog file.
 11. The system of claim 10, wherein the operations furthercomprise configuring the log replication receiver at the replicationtarget to run at an unmodified existing snapshot recovery service. 12.The system of claim 10, wherein the operations further compriseconfiguring a CDP metadata service to communicate with the logreplication sender and the log replication receiver.
 13. The system ofclaim 10, further comprising: configuring the log replication sender toidentify a log file to be replicated in the first plurality of log filesat the log receiver, and based on the identified log file including aclosed file, including contents of the log file in a closed replication.14. The system of claim 13, wherein the configuring the log replicationsender to identify a log file to be replicated in the first plurality oflog files at the log receiver and, based on the identified log fileincluding an open file receiving I/O data from the intercepted I/Ostream, including the I/O data in a live replication.
 15. Anon-transitory, machine-readable medium storing instructions which, whenread by a machine, cause the machine to perform operations in a methodfor continuous data protection for a virtual machine (VM) having avirtual disk, the operations comprising: receiving, at a backup site,I/O data intercepted from an I/O stream between a virtual machine (VM)and a virtualization server; flushing the I/O data to a first log file,the first log file being included in a first plurality of log files,each log file in the first plurality of log files, other than a secondlog file included in the first plurality of log files, including the I/Odata intercepted from the I/O stream between the VM and thevirtualization server, the second log file, of the first plurality oflog files, further including a base snapshot of the VM to form arecoverable snapshot-log chain; and pushing data to a replication targetbased on the recoverable snapshot-log chain.
 16. The non-transitorymachine-readable medium, of claim 15, wherein the operations furthercomprise: establishing an instance of a log replication sender at abackup site to communicate with a log replication receiver at areplication target; and determining a request for data from thereplication target.
 17. The non-transitory machine-readable medium, ofclaim 16, wherein the first plurality of log files includes a secondplurality of log files and wherein the operations further comprise:buffering the I/O data into memory before the flushing the I/O data to alog file; and removing the second plurality of log files from therecoverable snapshot-log chain based on a first service level agreementpolicy, the second plurality of log files including the second log file.18. The non-transitory machine-readable medium of claim 17, wherein theoperations further comprise configuring the log replication receiver atthe replication target to run at an unmodified existing snapshotrecovery service.
 19. The non-transitory machine-readable medium ofclaim 17, wherein the operations further comprise configuring a CDPmetadata service to communicate with the log replication sender and thelog replication receiver.
 20. The non-transitory machine-readable mediumof claim 17, wherein the operations further comprise: configuring thelog replication sender to identify a log file to be replicated in thefirst plurality of log files at the log receiver; and based on theidentified log file including a closed file, including contents of thelog file in a closed replication.